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, 2005
   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 "indirect_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 !defined __GNUC__ || __GNUC__ < 3
  49 #  define __builtin_expect(x, y) x
  50 #endif
  51
  52 /* If the size and opcode values are known at compile-time, this will, on
  53  * x86 at least, emit them with a single instruction.
  54  */
  55 #define emit_header(dest, op, size)            \
  56     do { union { short s[2]; int i; } temp;    \
  57          temp.s[0] = (size); temp.s[1] = (op); \
  58          *((int *)(dest)) = temp.i; } while(0)
  59
  60 NOINLINE CARD32
  61 __glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
  62 {
  63     xGLXSingleReply reply;
  64
  65     (void) _XReply(dpy, (xReply *) & reply, 0, False);
  66     if (size != 0) {
  67         if ((reply.length > 0) || reply_is_always_array) {
  68             const GLint bytes = (reply_is_always_array)
  69               ? (4 * reply.length) : (reply.size * size);
  70             const GLint extra = 4 - (bytes & 3);
  71
  72             _XRead(dpy, dest, bytes);
  73             if ( extra < 4 ) {
  74                 _XEatData(dpy, extra);
  75             }
  76         }
  77         else {
  78             (void) memcpy( dest, &(reply.pad3), size);
  79         }
  80     }
  81
  82     return reply.retval;
  83 }
  84
  85 NOINLINE void
  86 __glXReadPixelReply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
  87     GLint width, GLint height, GLint depth, GLenum format, GLenum type,
  88     void * dest, GLboolean dimensions_in_reply )
  89 {
  90     xGLXSingleReply reply;
  91     GLint size;
  92
  93     (void) _XReply(dpy, (xReply *) & reply, 0, False);
  94
  95     if ( dimensions_in_reply ) {
  96         width  = reply.pad3;
  97         height = reply.pad4;
  98         depth  = reply.pad5;
  99
 100         if ((height == 0) || (max_dim < 2)) { height = 1; }
 101         if ((depth  == 0) || (max_dim < 3)) { depth  = 1; }
 102     }
 103
 104     size = reply.length * 4;
 105     if (size != 0) {
 106         void * buf = Xmalloc( size );
 107
 108         if ( buf == NULL ) {
 109             _XEatData(dpy, size);
 110             __glXSetError(gc, GL_OUT_OF_MEMORY);
 111         }
 112         else {
 113             const GLint extra = 4 - (size & 3);
 114
 115             _XRead(dpy, buf, size);
 116             if ( extra < 4 ) {
 117                 _XEatData(dpy, extra);
 118             }
 119
 120             __glEmptyImage(gc, 3, width, height, depth, format, type,
 121                            buf, dest);
 122             Xfree(buf);
 123         }
 124     }
 125 }
 126
 127 #define X_GLXSingle 0
 128
 129 NOINLINE FASTCALL GLubyte *
 130 __glXSetupSingleRequest( __GLXcontext * gc, GLint sop, GLint cmdlen )
 131 {
 132     xGLXSingleReq * req;
 133     Display * const dpy = gc->currentDpy;
 134
 135     (void) __glXFlushRenderBuffer(gc, gc->pc);
 136     LockDisplay(dpy);
 137     GetReqExtra(GLXSingle, cmdlen, req);
 138     req->reqType = gc->majorOpcode;
 139     req->contextTag = gc->currentContextTag;
 140     req->glxCode = sop;
 141     return (GLubyte *)(req) + sz_xGLXSingleReq;
 142 }
 143
 144 NOINLINE FASTCALL GLubyte *
 145 __glXSetupVendorRequest( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
 146 {
 147     xGLXVendorPrivateReq * req;
 148     Display * const dpy = gc->currentDpy;
 149
 150     (void) __glXFlushRenderBuffer(gc, gc->pc);
 151     LockDisplay(dpy);
 152     GetReqExtra(GLXVendorPrivate, cmdlen, req);
 153     req->reqType = gc->majorOpcode;
 154     req->glxCode = code;
 155     req->vendorCode = vop;
 156     req->contextTag = gc->currentContextTag;
 157     return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
 158 }
 159
 160 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 161
 162 #define zero                        (__glXDefaultPixelStore+0)
 163 #define one                         (__glXDefaultPixelStore+8)
 164 #define default_pixel_store_1D      (__glXDefaultPixelStore+4)
 165 #define default_pixel_store_1D_size 20
 166 #define default_pixel_store_2D      (__glXDefaultPixelStore+4)
 167 #define default_pixel_store_2D_size 20
 168 #define default_pixel_store_3D      (__glXDefaultPixelStore+0)
 169 #define default_pixel_store_3D_size 36
 170 #define default_pixel_store_4D      (__glXDefaultPixelStore+0)
 171 #define default_pixel_store_4D_size 36
 172
 173 static FASTCALL NOINLINE void
 174 generic_3_byte( GLint rop, const void * ptr )
 175 {
 176     __GLXcontext * const gc = __glXGetCurrentContext();
 177     const GLuint cmdlen = 8;
 178
 179     emit_header(gc->pc, rop, cmdlen);
 180     (void) memcpy((void *)(gc->pc + 4), ptr, 4);
 181     gc->pc += cmdlen;
 182     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 183 }
 184
 185 static FASTCALL NOINLINE void
 186 generic_4_byte( GLint rop, const void * ptr )
 187 {
 188     __GLXcontext * const gc = __glXGetCurrentContext();
 189     const GLuint cmdlen = 8;
 190
 191     emit_header(gc->pc, rop, cmdlen);
 192     (void) memcpy((void *)(gc->pc + 4), ptr, 4);
 193     gc->pc += cmdlen;
 194     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 195 }
 196
 197 static FASTCALL NOINLINE void
 198 generic_6_byte( GLint rop, const void * ptr )
 199 {
 200     __GLXcontext * const gc = __glXGetCurrentContext();
 201     const GLuint cmdlen = 12;
 202
 203     emit_header(gc->pc, rop, cmdlen);
 204     (void) memcpy((void *)(gc->pc + 4), ptr, 8);
 205     gc->pc += cmdlen;
 206     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 207 }
 208
 209 static FASTCALL NOINLINE void
 210 generic_8_byte( GLint rop, const void * ptr )
 211 {
 212     __GLXcontext * const gc = __glXGetCurrentContext();
 213     const GLuint cmdlen = 12;
 214
 215     emit_header(gc->pc, rop, cmdlen);
 216     (void) memcpy((void *)(gc->pc + 4), ptr, 8);
 217     gc->pc += cmdlen;
 218     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 219 }
 220
 221 static FASTCALL NOINLINE void
 222 generic_12_byte( GLint rop, const void * ptr )
 223 {
 224     __GLXcontext * const gc = __glXGetCurrentContext();
 225     const GLuint cmdlen = 16;
 226
 227     emit_header(gc->pc, rop, cmdlen);
 228     (void) memcpy((void *)(gc->pc + 4), ptr, 12);
 229     gc->pc += cmdlen;
 230     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 231 }
 232
 233 static FASTCALL NOINLINE void
 234 generic_16_byte( GLint rop, const void * ptr )
 235 {
 236     __GLXcontext * const gc = __glXGetCurrentContext();
 237     const GLuint cmdlen = 20;
 238
 239     emit_header(gc->pc, rop, cmdlen);
 240     (void) memcpy((void *)(gc->pc + 4), ptr, 16);
 241     gc->pc += cmdlen;
 242     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 243 }
 244
 245 static FASTCALL NOINLINE void
 246 generic_24_byte( GLint rop, const void * ptr )
 247 {
 248     __GLXcontext * const gc = __glXGetCurrentContext();
 249     const GLuint cmdlen = 28;
 250
 251     emit_header(gc->pc, rop, cmdlen);
 252     (void) memcpy((void *)(gc->pc + 4), ptr, 24);
 253     gc->pc += cmdlen;
 254     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 255 }
 256
 257 static FASTCALL NOINLINE void
 258 generic_32_byte( GLint rop, const void * ptr )
 259 {
 260     __GLXcontext * const gc = __glXGetCurrentContext();
 261     const GLuint cmdlen = 36;
 262
 263     emit_header(gc->pc, rop, cmdlen);
 264     (void) memcpy((void *)(gc->pc + 4), ptr, 32);
 265     gc->pc += cmdlen;
 266     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 267 }
 268
 269 #define X_GLsop_NewList 101
 270 void
 271 __indirect_glNewList(GLuint list, GLenum mode)
 272 {
 273     __GLXcontext * const gc = __glXGetCurrentContext();
 274     Display * const dpy = gc->currentDpy;
 275     const GLuint cmdlen = 8;
 276     if (__builtin_expect(dpy != NULL, 1)) {
 277         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
 278         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
 279         (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
 280         UnlockDisplay(dpy); SyncHandle();
 281     }
 282     return;
 283 }
 284
 285 #define X_GLsop_EndList 102
 286 void
 287 __indirect_glEndList(void)
 288 {
 289     __GLXcontext * const gc = __glXGetCurrentContext();
 290     Display * const dpy = gc->currentDpy;
 291     const GLuint cmdlen = 0;
 292     if (__builtin_expect(dpy != NULL, 1)) {
 293         (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
 294         UnlockDisplay(dpy); SyncHandle();
 295     }
 296     return;
 297 }
 298
 299 #define X_GLrop_CallList 1
 300 void
 301 __indirect_glCallList(GLuint list)
 302 {
 303     __GLXcontext * const gc = __glXGetCurrentContext();
 304     const GLuint cmdlen = 8;
 305     emit_header(gc->pc, X_GLrop_CallList, cmdlen);
 306     (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
 307     gc->pc += cmdlen;
 308     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 309 }
 310
 311 #define X_GLrop_CallLists 2
 312 void
 313 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
 314 {
 315     __GLXcontext * const gc = __glXGetCurrentContext();
 316     const GLuint compsize = __glCallLists_size(type);
 317     const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
 318     if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
 319         if (cmdlen <= gc->maxSmallRenderCommandSize) {
 320             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
 321                 (void) __glXFlushRenderBuffer(gc, gc->pc);
 322             }
 323             emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
 324             (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
 325             (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
 326             (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
 327             gc->pc += cmdlen;
 328             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 329         }
 330         else {
 331             const GLint op = X_GLrop_CallLists;
 332             const GLuint cmdlenLarge = cmdlen + 4;
 333             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
 334             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
 335             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
 336             (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
 337             (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
 338             __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
 339         }
 340     }
 341 }
 342
 343 #define X_GLsop_DeleteLists 103
 344 void
 345 __indirect_glDeleteLists(GLuint list, GLsizei range)
 346 {
 347     __GLXcontext * const gc = __glXGetCurrentContext();
 348     Display * const dpy = gc->currentDpy;
 349     const GLuint cmdlen = 8;
 350     if (__builtin_expect(dpy != NULL, 1)) {
 351         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
 352         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
 353         (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
 354         UnlockDisplay(dpy); SyncHandle();
 355     }
 356     return;
 357 }
 358
 359 #define X_GLsop_GenLists 104
 360 GLuint
 361 __indirect_glGenLists(GLsizei range)
 362 {
 363     __GLXcontext * const gc = __glXGetCurrentContext();
 364     Display * const dpy = gc->currentDpy;
 365     GLuint retval = (GLuint) 0;
 366     const GLuint cmdlen = 4;
 367     if (__builtin_expect(dpy != NULL, 1)) {
 368         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
 369         (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
 370         retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
 371         UnlockDisplay(dpy); SyncHandle();
 372     }
 373     return retval;
 374 }
 375
 376 #define X_GLrop_ListBase 3
 377 void
 378 __indirect_glListBase(GLuint base)
 379 {
 380     __GLXcontext * const gc = __glXGetCurrentContext();
 381     const GLuint cmdlen = 8;
 382     emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
 383     (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
 384     gc->pc += cmdlen;
 385     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 386 }
 387
 388 #define X_GLrop_Begin 4
 389 void
 390 __indirect_glBegin(GLenum mode)
 391 {
 392     __GLXcontext * const gc = __glXGetCurrentContext();
 393     const GLuint cmdlen = 8;
 394     emit_header(gc->pc, X_GLrop_Begin, cmdlen);
 395     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
 396     gc->pc += cmdlen;
 397     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 398 }
 399
 400 #define X_GLrop_Bitmap 5
 401 void
 402 __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
 403 {
 404     __GLXcontext * const gc = __glXGetCurrentContext();
 405     const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
 406     const GLuint cmdlen = 48 + __GLX_PAD(compsize);
 407     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
 408         if (cmdlen <= gc->maxSmallRenderCommandSize) {
 409             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
 410                 (void) __glXFlushRenderBuffer(gc, gc->pc);
 411             }
 412             emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
 413             (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
 414             (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
 415             (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4);
 416             (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4);
 417             (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4);
 418             (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4);
 419             if (compsize > 0) {
 420                 (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
 421             }
 422             else {
 423                 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
 424             }
 425             gc->pc += cmdlen;
 426             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 427         }
 428         else {
 429             const GLint op = X_GLrop_Bitmap;
 430             const GLuint cmdlenLarge = cmdlen + 4;
 431             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
 432             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
 433             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
 434             (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
 435             (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
 436             (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4);
 437             (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4);
 438             (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4);
 439             (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4);
 440             __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8);
 441         }
 442     }
 443 }
 444
 445 #define X_GLrop_Color3bv 6
 446 void
 447 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 448 {
 449     __GLXcontext * const gc = __glXGetCurrentContext();
 450     const GLuint cmdlen = 8;
 451     emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
 452     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 453     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 454     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 455     gc->pc += cmdlen;
 456     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 457 }
 458
 459 #define X_GLrop_Color3bv 6
 460 void
 461 __indirect_glColor3bv(const GLbyte * v)
 462 {
 463     generic_3_byte( X_GLrop_Color3bv, v );
 464 }
 465
 466 #define X_GLrop_Color3dv 7
 467 void
 468 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 469 {
 470     __GLXcontext * const gc = __glXGetCurrentContext();
 471     const GLuint cmdlen = 28;
 472     emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
 473     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
 474     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
 475     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
 476     gc->pc += cmdlen;
 477     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 478 }
 479
 480 #define X_GLrop_Color3dv 7
 481 void
 482 __indirect_glColor3dv(const GLdouble * v)
 483 {
 484     generic_24_byte( X_GLrop_Color3dv, v );
 485 }
 486
 487 #define X_GLrop_Color3fv 8
 488 void
 489 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 490 {
 491     __GLXcontext * const gc = __glXGetCurrentContext();
 492     const GLuint cmdlen = 16;
 493     emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
 494     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 495     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 496     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 497     gc->pc += cmdlen;
 498     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 499 }
 500
 501 #define X_GLrop_Color3fv 8
 502 void
 503 __indirect_glColor3fv(const GLfloat * v)
 504 {
 505     generic_12_byte( X_GLrop_Color3fv, v );
 506 }
 507
 508 #define X_GLrop_Color3iv 9
 509 void
 510 __indirect_glColor3i(GLint red, GLint green, GLint blue)
 511 {
 512     __GLXcontext * const gc = __glXGetCurrentContext();
 513     const GLuint cmdlen = 16;
 514     emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
 515     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 516     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 517     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 518     gc->pc += cmdlen;
 519     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 520 }
 521
 522 #define X_GLrop_Color3iv 9
 523 void
 524 __indirect_glColor3iv(const GLint * v)
 525 {
 526     generic_12_byte( X_GLrop_Color3iv, v );
 527 }
 528
 529 #define X_GLrop_Color3sv 10
 530 void
 531 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
 532 {
 533     __GLXcontext * const gc = __glXGetCurrentContext();
 534     const GLuint cmdlen = 12;
 535     emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
 536     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 537     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 538     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 539     gc->pc += cmdlen;
 540     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 541 }
 542
 543 #define X_GLrop_Color3sv 10
 544 void
 545 __indirect_glColor3sv(const GLshort * v)
 546 {
 547     generic_6_byte( X_GLrop_Color3sv, v );
 548 }
 549
 550 #define X_GLrop_Color3ubv 11
 551 void
 552 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 553 {
 554     __GLXcontext * const gc = __glXGetCurrentContext();
 555     const GLuint cmdlen = 8;
 556     emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
 557     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 558     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 559     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 560     gc->pc += cmdlen;
 561     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 562 }
 563
 564 #define X_GLrop_Color3ubv 11
 565 void
 566 __indirect_glColor3ubv(const GLubyte * v)
 567 {
 568     generic_3_byte( X_GLrop_Color3ubv, v );
 569 }
 570
 571 #define X_GLrop_Color3uiv 12
 572 void
 573 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
 574 {
 575     __GLXcontext * const gc = __glXGetCurrentContext();
 576     const GLuint cmdlen = 16;
 577     emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
 578     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 579     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 580     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 581     gc->pc += cmdlen;
 582     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 583 }
 584
 585 #define X_GLrop_Color3uiv 12
 586 void
 587 __indirect_glColor3uiv(const GLuint * v)
 588 {
 589     generic_12_byte( X_GLrop_Color3uiv, v );
 590 }
 591
 592 #define X_GLrop_Color3usv 13
 593 void
 594 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
 595 {
 596     __GLXcontext * const gc = __glXGetCurrentContext();
 597     const GLuint cmdlen = 12;
 598     emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
 599     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 600     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 601     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 602     gc->pc += cmdlen;
 603     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 604 }
 605
 606 #define X_GLrop_Color3usv 13
 607 void
 608 __indirect_glColor3usv(const GLushort * v)
 609 {
 610     generic_6_byte( X_GLrop_Color3usv, v );
 611 }
 612
 613 #define X_GLrop_Color4bv 14
 614 void
 615 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 616 {
 617     __GLXcontext * const gc = __glXGetCurrentContext();
 618     const GLuint cmdlen = 8;
 619     emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
 620     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 621     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 622     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 623     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
 624     gc->pc += cmdlen;
 625     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 626 }
 627
 628 #define X_GLrop_Color4bv 14
 629 void
 630 __indirect_glColor4bv(const GLbyte * v)
 631 {
 632     generic_4_byte( X_GLrop_Color4bv, v );
 633 }
 634
 635 #define X_GLrop_Color4dv 15
 636 void
 637 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 638 {
 639     __GLXcontext * const gc = __glXGetCurrentContext();
 640     const GLuint cmdlen = 36;
 641     emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
 642     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
 643     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
 644     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
 645     (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
 646     gc->pc += cmdlen;
 647     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 648 }
 649
 650 #define X_GLrop_Color4dv 15
 651 void
 652 __indirect_glColor4dv(const GLdouble * v)
 653 {
 654     generic_32_byte( X_GLrop_Color4dv, v );
 655 }
 656
 657 #define X_GLrop_Color4fv 16
 658 void
 659 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 660 {
 661     __GLXcontext * const gc = __glXGetCurrentContext();
 662     const GLuint cmdlen = 20;
 663     emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
 664     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 665     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 666     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 667     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 668     gc->pc += cmdlen;
 669     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 670 }
 671
 672 #define X_GLrop_Color4fv 16
 673 void
 674 __indirect_glColor4fv(const GLfloat * v)
 675 {
 676     generic_16_byte( X_GLrop_Color4fv, v );
 677 }
 678
 679 #define X_GLrop_Color4iv 17
 680 void
 681 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 682 {
 683     __GLXcontext * const gc = __glXGetCurrentContext();
 684     const GLuint cmdlen = 20;
 685     emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
 686     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 687     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 688     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 689     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 690     gc->pc += cmdlen;
 691     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 692 }
 693
 694 #define X_GLrop_Color4iv 17
 695 void
 696 __indirect_glColor4iv(const GLint * v)
 697 {
 698     generic_16_byte( X_GLrop_Color4iv, v );
 699 }
 700
 701 #define X_GLrop_Color4sv 18
 702 void
 703 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 704 {
 705     __GLXcontext * const gc = __glXGetCurrentContext();
 706     const GLuint cmdlen = 12;
 707     emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
 708     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 709     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 710     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 711     (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
 712     gc->pc += cmdlen;
 713     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 714 }
 715
 716 #define X_GLrop_Color4sv 18
 717 void
 718 __indirect_glColor4sv(const GLshort * v)
 719 {
 720     generic_8_byte( X_GLrop_Color4sv, v );
 721 }
 722
 723 #define X_GLrop_Color4ubv 19
 724 void
 725 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 726 {
 727     __GLXcontext * const gc = __glXGetCurrentContext();
 728     const GLuint cmdlen = 8;
 729     emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
 730     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 731     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 732     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 733     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
 734     gc->pc += cmdlen;
 735     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 736 }
 737
 738 #define X_GLrop_Color4ubv 19
 739 void
 740 __indirect_glColor4ubv(const GLubyte * v)
 741 {
 742     generic_4_byte( X_GLrop_Color4ubv, v );
 743 }
 744
 745 #define X_GLrop_Color4uiv 20
 746 void
 747 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 748 {
 749     __GLXcontext * const gc = __glXGetCurrentContext();
 750     const GLuint cmdlen = 20;
 751     emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
 752     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 753     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 754     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 755     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 756     gc->pc += cmdlen;
 757     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 758 }
 759
 760 #define X_GLrop_Color4uiv 20
 761 void
 762 __indirect_glColor4uiv(const GLuint * v)
 763 {
 764     generic_16_byte( X_GLrop_Color4uiv, v );
 765 }
 766
 767 #define X_GLrop_Color4usv 21
 768 void
 769 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 770 {
 771     __GLXcontext * const gc = __glXGetCurrentContext();
 772     const GLuint cmdlen = 12;
 773     emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
 774     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 775     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 776     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 777     (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
 778     gc->pc += cmdlen;
 779     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 780 }
 781
 782 #define X_GLrop_Color4usv 21
 783 void
 784 __indirect_glColor4usv(const GLushort * v)
 785 {
 786     generic_8_byte( X_GLrop_Color4usv, v );
 787 }
 788
 789 #define X_GLrop_EdgeFlagv 22
 790 void
 791 __indirect_glEdgeFlag(GLboolean flag)
 792 {
 793     __GLXcontext * const gc = __glXGetCurrentContext();
 794     const GLuint cmdlen = 8;
 795     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
 796     (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
 797     gc->pc += cmdlen;
 798     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 799 }
 800
 801 #define X_GLrop_EdgeFlagv 22
 802 void
 803 __indirect_glEdgeFlagv(const GLboolean * flag)
 804 {
 805     __GLXcontext * const gc = __glXGetCurrentContext();
 806     const GLuint cmdlen = 8;
 807     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
 808     (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
 809     gc->pc += cmdlen;
 810     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 811 }
 812
 813 #define X_GLrop_End 23
 814 void
 815 __indirect_glEnd(void)
 816 {
 817     __GLXcontext * const gc = __glXGetCurrentContext();
 818     const GLuint cmdlen = 4;
 819     emit_header(gc->pc, X_GLrop_End, cmdlen);
 820     gc->pc += cmdlen;
 821     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 822 }
 823
 824 #define X_GLrop_Indexdv 24
 825 void
 826 __indirect_glIndexd(GLdouble c)
 827 {
 828     __GLXcontext * const gc = __glXGetCurrentContext();
 829     const GLuint cmdlen = 12;
 830     emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
 831     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
 832     gc->pc += cmdlen;
 833     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 834 }
 835
 836 #define X_GLrop_Indexdv 24
 837 void
 838 __indirect_glIndexdv(const GLdouble * c)
 839 {
 840     generic_8_byte( X_GLrop_Indexdv, c );
 841 }
 842
 843 #define X_GLrop_Indexfv 25
 844 void
 845 __indirect_glIndexf(GLfloat c)
 846 {
 847     __GLXcontext * const gc = __glXGetCurrentContext();
 848     const GLuint cmdlen = 8;
 849     emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
 850     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
 851     gc->pc += cmdlen;
 852     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 853 }
 854
 855 #define X_GLrop_Indexfv 25
 856 void
 857 __indirect_glIndexfv(const GLfloat * c)
 858 {
 859     generic_4_byte( X_GLrop_Indexfv, c );
 860 }
 861
 862 #define X_GLrop_Indexiv 26
 863 void
 864 __indirect_glIndexi(GLint c)
 865 {
 866     __GLXcontext * const gc = __glXGetCurrentContext();
 867     const GLuint cmdlen = 8;
 868     emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
 869     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
 870     gc->pc += cmdlen;
 871     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 872 }
 873
 874 #define X_GLrop_Indexiv 26
 875 void
 876 __indirect_glIndexiv(const GLint * c)
 877 {
 878     generic_4_byte( X_GLrop_Indexiv, c );
 879 }
 880
 881 #define X_GLrop_Indexsv 27
 882 void
 883 __indirect_glIndexs(GLshort c)
 884 {
 885     __GLXcontext * const gc = __glXGetCurrentContext();
 886     const GLuint cmdlen = 8;
 887     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
 888     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
 889     gc->pc += cmdlen;
 890     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 891 }
 892
 893 #define X_GLrop_Indexsv 27
 894 void
 895 __indirect_glIndexsv(const GLshort * c)
 896 {
 897     __GLXcontext * const gc = __glXGetCurrentContext();
 898     const GLuint cmdlen = 8;
 899     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
 900     (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
 901     gc->pc += cmdlen;
 902     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 903 }
 904
 905 #define X_GLrop_Normal3bv 28
 906 void
 907 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 908 {
 909     __GLXcontext * const gc = __glXGetCurrentContext();
 910     const GLuint cmdlen = 8;
 911     emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
 912     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
 913     (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
 914     (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
 915     gc->pc += cmdlen;
 916     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 917 }
 918
 919 #define X_GLrop_Normal3bv 28
 920 void
 921 __indirect_glNormal3bv(const GLbyte * v)
 922 {
 923     generic_3_byte( X_GLrop_Normal3bv, v );
 924 }
 925
 926 #define X_GLrop_Normal3dv 29
 927 void
 928 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 929 {
 930     __GLXcontext * const gc = __glXGetCurrentContext();
 931     const GLuint cmdlen = 28;
 932     emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
 933     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
 934     (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
 935     (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
 936     gc->pc += cmdlen;
 937     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 938 }
 939
 940 #define X_GLrop_Normal3dv 29
 941 void
 942 __indirect_glNormal3dv(const GLdouble * v)
 943 {
 944     generic_24_byte( X_GLrop_Normal3dv, v );
 945 }
 946
 947 #define X_GLrop_Normal3fv 30
 948 void
 949 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 950 {
 951     __GLXcontext * const gc = __glXGetCurrentContext();
 952     const GLuint cmdlen = 16;
 953     emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
 954     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
 955     (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
 956     (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
 957     gc->pc += cmdlen;
 958     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 959 }
 960
 961 #define X_GLrop_Normal3fv 30
 962 void
 963 __indirect_glNormal3fv(const GLfloat * v)
 964 {
 965     generic_12_byte( X_GLrop_Normal3fv, v );
 966 }
 967
 968 #define X_GLrop_Normal3iv 31
 969 void
 970 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
 971 {
 972     __GLXcontext * const gc = __glXGetCurrentContext();
 973     const GLuint cmdlen = 16;
 974     emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
 975     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
 976     (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
 977     (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
 978     gc->pc += cmdlen;
 979     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 980 }
 981
 982 #define X_GLrop_Normal3iv 31
 983 void
 984 __indirect_glNormal3iv(const GLint * v)
 985 {
 986     generic_12_byte( X_GLrop_Normal3iv, v );
 987 }
 988
 989 #define X_GLrop_Normal3sv 32
 990 void
 991 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 992 {
 993     __GLXcontext * const gc = __glXGetCurrentContext();
 994     const GLuint cmdlen = 12;
 995     emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
 996     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
 997     (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
 998     (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
 999     gc->pc += cmdlen;
1000     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1001 }
1002
1003 #define X_GLrop_Normal3sv 32
1004 void
1005 __indirect_glNormal3sv(const GLshort * v)
1006 {
1007     generic_6_byte( X_GLrop_Normal3sv, v );
1008 }
1009
1010 #define X_GLrop_RasterPos2dv 33
1011 void
1012 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
1013 {
1014     __GLXcontext * const gc = __glXGetCurrentContext();
1015     const GLuint cmdlen = 20;
1016     emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
1017     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1018     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1019     gc->pc += cmdlen;
1020     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1021 }
1022
1023 #define X_GLrop_RasterPos2dv 33
1024 void
1025 __indirect_glRasterPos2dv(const GLdouble * v)
1026 {
1027     generic_16_byte( X_GLrop_RasterPos2dv, v );
1028 }
1029
1030 #define X_GLrop_RasterPos2fv 34
1031 void
1032 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
1033 {
1034     __GLXcontext * const gc = __glXGetCurrentContext();
1035     const GLuint cmdlen = 12;
1036     emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1037     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1038     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1039     gc->pc += cmdlen;
1040     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1041 }
1042
1043 #define X_GLrop_RasterPos2fv 34
1044 void
1045 __indirect_glRasterPos2fv(const GLfloat * v)
1046 {
1047     generic_8_byte( X_GLrop_RasterPos2fv, v );
1048 }
1049
1050 #define X_GLrop_RasterPos2iv 35
1051 void
1052 __indirect_glRasterPos2i(GLint x, GLint y)
1053 {
1054     __GLXcontext * const gc = __glXGetCurrentContext();
1055     const GLuint cmdlen = 12;
1056     emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1057     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1058     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1059     gc->pc += cmdlen;
1060     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1061 }
1062
1063 #define X_GLrop_RasterPos2iv 35
1064 void
1065 __indirect_glRasterPos2iv(const GLint * v)
1066 {
1067     generic_8_byte( X_GLrop_RasterPos2iv, v );
1068 }
1069
1070 #define X_GLrop_RasterPos2sv 36
1071 void
1072 __indirect_glRasterPos2s(GLshort x, GLshort y)
1073 {
1074     __GLXcontext * const gc = __glXGetCurrentContext();
1075     const GLuint cmdlen = 8;
1076     emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1077     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1078     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1079     gc->pc += cmdlen;
1080     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1081 }
1082
1083 #define X_GLrop_RasterPos2sv 36
1084 void
1085 __indirect_glRasterPos2sv(const GLshort * v)
1086 {
1087     generic_4_byte( X_GLrop_RasterPos2sv, v );
1088 }
1089
1090 #define X_GLrop_RasterPos3dv 37
1091 void
1092 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1093 {
1094     __GLXcontext * const gc = __glXGetCurrentContext();
1095     const GLuint cmdlen = 28;
1096     emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1097     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1098     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1099     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1100     gc->pc += cmdlen;
1101     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1102 }
1103
1104 #define X_GLrop_RasterPos3dv 37
1105 void
1106 __indirect_glRasterPos3dv(const GLdouble * v)
1107 {
1108     generic_24_byte( X_GLrop_RasterPos3dv, v );
1109 }
1110
1111 #define X_GLrop_RasterPos3fv 38
1112 void
1113 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1114 {
1115     __GLXcontext * const gc = __glXGetCurrentContext();
1116     const GLuint cmdlen = 16;
1117     emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1118     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1119     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1120     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1121     gc->pc += cmdlen;
1122     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1123 }
1124
1125 #define X_GLrop_RasterPos3fv 38
1126 void
1127 __indirect_glRasterPos3fv(const GLfloat * v)
1128 {
1129     generic_12_byte( X_GLrop_RasterPos3fv, v );
1130 }
1131
1132 #define X_GLrop_RasterPos3iv 39
1133 void
1134 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1135 {
1136     __GLXcontext * const gc = __glXGetCurrentContext();
1137     const GLuint cmdlen = 16;
1138     emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1139     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1140     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1141     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1142     gc->pc += cmdlen;
1143     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1144 }
1145
1146 #define X_GLrop_RasterPos3iv 39
1147 void
1148 __indirect_glRasterPos3iv(const GLint * v)
1149 {
1150     generic_12_byte( X_GLrop_RasterPos3iv, v );
1151 }
1152
1153 #define X_GLrop_RasterPos3sv 40
1154 void
1155 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1156 {
1157     __GLXcontext * const gc = __glXGetCurrentContext();
1158     const GLuint cmdlen = 12;
1159     emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1160     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1161     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1162     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1163     gc->pc += cmdlen;
1164     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1165 }
1166
1167 #define X_GLrop_RasterPos3sv 40
1168 void
1169 __indirect_glRasterPos3sv(const GLshort * v)
1170 {
1171     generic_6_byte( X_GLrop_RasterPos3sv, v );
1172 }
1173
1174 #define X_GLrop_RasterPos4dv 41
1175 void
1176 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1177 {
1178     __GLXcontext * const gc = __glXGetCurrentContext();
1179     const GLuint cmdlen = 36;
1180     emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1181     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1182     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1183     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1184     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1185     gc->pc += cmdlen;
1186     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1187 }
1188
1189 #define X_GLrop_RasterPos4dv 41
1190 void
1191 __indirect_glRasterPos4dv(const GLdouble * v)
1192 {
1193     generic_32_byte( X_GLrop_RasterPos4dv, v );
1194 }
1195
1196 #define X_GLrop_RasterPos4fv 42
1197 void
1198 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1199 {
1200     __GLXcontext * const gc = __glXGetCurrentContext();
1201     const GLuint cmdlen = 20;
1202     emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1203     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1204     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1205     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1206     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1207     gc->pc += cmdlen;
1208     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1209 }
1210
1211 #define X_GLrop_RasterPos4fv 42
1212 void
1213 __indirect_glRasterPos4fv(const GLfloat * v)
1214 {
1215     generic_16_byte( X_GLrop_RasterPos4fv, v );
1216 }
1217
1218 #define X_GLrop_RasterPos4iv 43
1219 void
1220 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1221 {
1222     __GLXcontext * const gc = __glXGetCurrentContext();
1223     const GLuint cmdlen = 20;
1224     emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1225     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1226     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1227     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1228     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1229     gc->pc += cmdlen;
1230     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1231 }
1232
1233 #define X_GLrop_RasterPos4iv 43
1234 void
1235 __indirect_glRasterPos4iv(const GLint * v)
1236 {
1237     generic_16_byte( X_GLrop_RasterPos4iv, v );
1238 }
1239
1240 #define X_GLrop_RasterPos4sv 44
1241 void
1242 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1243 {
1244     __GLXcontext * const gc = __glXGetCurrentContext();
1245     const GLuint cmdlen = 12;
1246     emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1247     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1248     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1249     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1250     (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1251     gc->pc += cmdlen;
1252     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1253 }
1254
1255 #define X_GLrop_RasterPos4sv 44
1256 void
1257 __indirect_glRasterPos4sv(const GLshort * v)
1258 {
1259     generic_8_byte( X_GLrop_RasterPos4sv, v );
1260 }
1261
1262 #define X_GLrop_Rectdv 45
1263 void
1264 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1265 {
1266     __GLXcontext * const gc = __glXGetCurrentContext();
1267     const GLuint cmdlen = 36;
1268     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1269     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
1270     (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
1271     (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
1272     (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
1273     gc->pc += cmdlen;
1274     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1275 }
1276
1277 #define X_GLrop_Rectdv 45
1278 void
1279 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1280 {
1281     __GLXcontext * const gc = __glXGetCurrentContext();
1282     const GLuint cmdlen = 36;
1283     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1284     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
1285     (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
1286     gc->pc += cmdlen;
1287     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1288 }
1289
1290 #define X_GLrop_Rectfv 46
1291 void
1292 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1293 {
1294     __GLXcontext * const gc = __glXGetCurrentContext();
1295     const GLuint cmdlen = 20;
1296     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1297     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1298     (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1299     (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1300     (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1301     gc->pc += cmdlen;
1302     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1303 }
1304
1305 #define X_GLrop_Rectfv 46
1306 void
1307 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1308 {
1309     __GLXcontext * const gc = __glXGetCurrentContext();
1310     const GLuint cmdlen = 20;
1311     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1312     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1313     (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1314     gc->pc += cmdlen;
1315     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1316 }
1317
1318 #define X_GLrop_Rectiv 47
1319 void
1320 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1321 {
1322     __GLXcontext * const gc = __glXGetCurrentContext();
1323     const GLuint cmdlen = 20;
1324     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1325     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1326     (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1327     (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1328     (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1329     gc->pc += cmdlen;
1330     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1331 }
1332
1333 #define X_GLrop_Rectiv 47
1334 void
1335 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1336 {
1337     __GLXcontext * const gc = __glXGetCurrentContext();
1338     const GLuint cmdlen = 20;
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 (__builtin_expect(gc->pc > gc->limit, 0)) { (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     const GLuint cmdlen = 12;
1352     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1353     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
1354     (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
1355     (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
1356     (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
1357     gc->pc += cmdlen;
1358     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1359 }
1360
1361 #define X_GLrop_Rectsv 48
1362 void
1363 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1364 {
1365     __GLXcontext * const gc = __glXGetCurrentContext();
1366     const GLuint cmdlen = 12;
1367     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1368     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
1369     (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
1370     gc->pc += cmdlen;
1371     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1372 }
1373
1374 #define X_GLrop_TexCoord1dv 49
1375 void
1376 __indirect_glTexCoord1d(GLdouble s)
1377 {
1378     __GLXcontext * const gc = __glXGetCurrentContext();
1379     const GLuint cmdlen = 12;
1380     emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1381     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1382     gc->pc += cmdlen;
1383     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1384 }
1385
1386 #define X_GLrop_TexCoord1dv 49
1387 void
1388 __indirect_glTexCoord1dv(const GLdouble * v)
1389 {
1390     generic_8_byte( X_GLrop_TexCoord1dv, v );
1391 }
1392
1393 #define X_GLrop_TexCoord1fv 50
1394 void
1395 __indirect_glTexCoord1f(GLfloat s)
1396 {
1397     __GLXcontext * const gc = __glXGetCurrentContext();
1398     const GLuint cmdlen = 8;
1399     emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1400     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1401     gc->pc += cmdlen;
1402     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1403 }
1404
1405 #define X_GLrop_TexCoord1fv 50
1406 void
1407 __indirect_glTexCoord1fv(const GLfloat * v)
1408 {
1409     generic_4_byte( X_GLrop_TexCoord1fv, v );
1410 }
1411
1412 #define X_GLrop_TexCoord1iv 51
1413 void
1414 __indirect_glTexCoord1i(GLint s)
1415 {
1416     __GLXcontext * const gc = __glXGetCurrentContext();
1417     const GLuint cmdlen = 8;
1418     emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1419     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1420     gc->pc += cmdlen;
1421     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1422 }
1423
1424 #define X_GLrop_TexCoord1iv 51
1425 void
1426 __indirect_glTexCoord1iv(const GLint * v)
1427 {
1428     generic_4_byte( X_GLrop_TexCoord1iv, v );
1429 }
1430
1431 #define X_GLrop_TexCoord1sv 52
1432 void
1433 __indirect_glTexCoord1s(GLshort s)
1434 {
1435     __GLXcontext * const gc = __glXGetCurrentContext();
1436     const GLuint cmdlen = 8;
1437     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1438     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1439     gc->pc += cmdlen;
1440     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1441 }
1442
1443 #define X_GLrop_TexCoord1sv 52
1444 void
1445 __indirect_glTexCoord1sv(const GLshort * v)
1446 {
1447     __GLXcontext * const gc = __glXGetCurrentContext();
1448     const GLuint cmdlen = 8;
1449     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1450     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
1451     gc->pc += cmdlen;
1452     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1453 }
1454
1455 #define X_GLrop_TexCoord2dv 53
1456 void
1457 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1458 {
1459     __GLXcontext * const gc = __glXGetCurrentContext();
1460     const GLuint cmdlen = 20;
1461     emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1462     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1463     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1464     gc->pc += cmdlen;
1465     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1466 }
1467
1468 #define X_GLrop_TexCoord2dv 53
1469 void
1470 __indirect_glTexCoord2dv(const GLdouble * v)
1471 {
1472     generic_16_byte( X_GLrop_TexCoord2dv, v );
1473 }
1474
1475 #define X_GLrop_TexCoord2fv 54
1476 void
1477 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1478 {
1479     __GLXcontext * const gc = __glXGetCurrentContext();
1480     const GLuint cmdlen = 12;
1481     emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1482     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1483     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1484     gc->pc += cmdlen;
1485     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1486 }
1487
1488 #define X_GLrop_TexCoord2fv 54
1489 void
1490 __indirect_glTexCoord2fv(const GLfloat * v)
1491 {
1492     generic_8_byte( X_GLrop_TexCoord2fv, v );
1493 }
1494
1495 #define X_GLrop_TexCoord2iv 55
1496 void
1497 __indirect_glTexCoord2i(GLint s, GLint t)
1498 {
1499     __GLXcontext * const gc = __glXGetCurrentContext();
1500     const GLuint cmdlen = 12;
1501     emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1502     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1503     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1504     gc->pc += cmdlen;
1505     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1506 }
1507
1508 #define X_GLrop_TexCoord2iv 55
1509 void
1510 __indirect_glTexCoord2iv(const GLint * v)
1511 {
1512     generic_8_byte( X_GLrop_TexCoord2iv, v );
1513 }
1514
1515 #define X_GLrop_TexCoord2sv 56
1516 void
1517 __indirect_glTexCoord2s(GLshort s, GLshort t)
1518 {
1519     __GLXcontext * const gc = __glXGetCurrentContext();
1520     const GLuint cmdlen = 8;
1521     emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1522     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1523     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1524     gc->pc += cmdlen;
1525     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1526 }
1527
1528 #define X_GLrop_TexCoord2sv 56
1529 void
1530 __indirect_glTexCoord2sv(const GLshort * v)
1531 {
1532     generic_4_byte( X_GLrop_TexCoord2sv, v );
1533 }
1534
1535 #define X_GLrop_TexCoord3dv 57
1536 void
1537 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1538 {
1539     __GLXcontext * const gc = __glXGetCurrentContext();
1540     const GLuint cmdlen = 28;
1541     emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1542     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1543     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1544     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1545     gc->pc += cmdlen;
1546     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1547 }
1548
1549 #define X_GLrop_TexCoord3dv 57
1550 void
1551 __indirect_glTexCoord3dv(const GLdouble * v)
1552 {
1553     generic_24_byte( X_GLrop_TexCoord3dv, v );
1554 }
1555
1556 #define X_GLrop_TexCoord3fv 58
1557 void
1558 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1559 {
1560     __GLXcontext * const gc = __glXGetCurrentContext();
1561     const GLuint cmdlen = 16;
1562     emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1563     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1564     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1565     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1566     gc->pc += cmdlen;
1567     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1568 }
1569
1570 #define X_GLrop_TexCoord3fv 58
1571 void
1572 __indirect_glTexCoord3fv(const GLfloat * v)
1573 {
1574     generic_12_byte( X_GLrop_TexCoord3fv, v );
1575 }
1576
1577 #define X_GLrop_TexCoord3iv 59
1578 void
1579 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1580 {
1581     __GLXcontext * const gc = __glXGetCurrentContext();
1582     const GLuint cmdlen = 16;
1583     emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1584     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1585     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1586     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1587     gc->pc += cmdlen;
1588     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1589 }
1590
1591 #define X_GLrop_TexCoord3iv 59
1592 void
1593 __indirect_glTexCoord3iv(const GLint * v)
1594 {
1595     generic_12_byte( X_GLrop_TexCoord3iv, v );
1596 }
1597
1598 #define X_GLrop_TexCoord3sv 60
1599 void
1600 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1601 {
1602     __GLXcontext * const gc = __glXGetCurrentContext();
1603     const GLuint cmdlen = 12;
1604     emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1605     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1606     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1607     (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1608     gc->pc += cmdlen;
1609     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1610 }
1611
1612 #define X_GLrop_TexCoord3sv 60
1613 void
1614 __indirect_glTexCoord3sv(const GLshort * v)
1615 {
1616     generic_6_byte( X_GLrop_TexCoord3sv, v );
1617 }
1618
1619 #define X_GLrop_TexCoord4dv 61
1620 void
1621 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1622 {
1623     __GLXcontext * const gc = __glXGetCurrentContext();
1624     const GLuint cmdlen = 36;
1625     emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1626     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1627     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1628     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1629     (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
1630     gc->pc += cmdlen;
1631     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1632 }
1633
1634 #define X_GLrop_TexCoord4dv 61
1635 void
1636 __indirect_glTexCoord4dv(const GLdouble * v)
1637 {
1638     generic_32_byte( X_GLrop_TexCoord4dv, v );
1639 }
1640
1641 #define X_GLrop_TexCoord4fv 62
1642 void
1643 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1644 {
1645     __GLXcontext * const gc = __glXGetCurrentContext();
1646     const GLuint cmdlen = 20;
1647     emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1648     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1649     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1650     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1651     (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1652     gc->pc += cmdlen;
1653     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1654 }
1655
1656 #define X_GLrop_TexCoord4fv 62
1657 void
1658 __indirect_glTexCoord4fv(const GLfloat * v)
1659 {
1660     generic_16_byte( X_GLrop_TexCoord4fv, v );
1661 }
1662
1663 #define X_GLrop_TexCoord4iv 63
1664 void
1665 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1666 {
1667     __GLXcontext * const gc = __glXGetCurrentContext();
1668     const GLuint cmdlen = 20;
1669     emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1670     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1671     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1672     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1673     (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1674     gc->pc += cmdlen;
1675     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1676 }
1677
1678 #define X_GLrop_TexCoord4iv 63
1679 void
1680 __indirect_glTexCoord4iv(const GLint * v)
1681 {
1682     generic_16_byte( X_GLrop_TexCoord4iv, v );
1683 }
1684
1685 #define X_GLrop_TexCoord4sv 64
1686 void
1687 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1688 {
1689     __GLXcontext * const gc = __glXGetCurrentContext();
1690     const GLuint cmdlen = 12;
1691     emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1692     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1693     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1694     (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1695     (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
1696     gc->pc += cmdlen;
1697     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1698 }
1699
1700 #define X_GLrop_TexCoord4sv 64
1701 void
1702 __indirect_glTexCoord4sv(const GLshort * v)
1703 {
1704     generic_8_byte( X_GLrop_TexCoord4sv, v );
1705 }
1706
1707 #define X_GLrop_Vertex2dv 65
1708 void
1709 __indirect_glVertex2d(GLdouble x, GLdouble y)
1710 {
1711     __GLXcontext * const gc = __glXGetCurrentContext();
1712     const GLuint cmdlen = 20;
1713     emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1714     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1715     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1716     gc->pc += cmdlen;
1717     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1718 }
1719
1720 #define X_GLrop_Vertex2dv 65
1721 void
1722 __indirect_glVertex2dv(const GLdouble * v)
1723 {
1724     generic_16_byte( X_GLrop_Vertex2dv, v );
1725 }
1726
1727 #define X_GLrop_Vertex2fv 66
1728 void
1729 __indirect_glVertex2f(GLfloat x, GLfloat y)
1730 {
1731     __GLXcontext * const gc = __glXGetCurrentContext();
1732     const GLuint cmdlen = 12;
1733     emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1734     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1735     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1736     gc->pc += cmdlen;
1737     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1738 }
1739
1740 #define X_GLrop_Vertex2fv 66
1741 void
1742 __indirect_glVertex2fv(const GLfloat * v)
1743 {
1744     generic_8_byte( X_GLrop_Vertex2fv, v );
1745 }
1746
1747 #define X_GLrop_Vertex2iv 67
1748 void
1749 __indirect_glVertex2i(GLint x, GLint y)
1750 {
1751     __GLXcontext * const gc = __glXGetCurrentContext();
1752     const GLuint cmdlen = 12;
1753     emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1754     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1755     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1756     gc->pc += cmdlen;
1757     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1758 }
1759
1760 #define X_GLrop_Vertex2iv 67
1761 void
1762 __indirect_glVertex2iv(const GLint * v)
1763 {
1764     generic_8_byte( X_GLrop_Vertex2iv, v );
1765 }
1766
1767 #define X_GLrop_Vertex2sv 68
1768 void
1769 __indirect_glVertex2s(GLshort x, GLshort y)
1770 {
1771     __GLXcontext * const gc = __glXGetCurrentContext();
1772     const GLuint cmdlen = 8;
1773     emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
1774     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1775     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1776     gc->pc += cmdlen;
1777     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1778 }
1779
1780 #define X_GLrop_Vertex2sv 68
1781 void
1782 __indirect_glVertex2sv(const GLshort * v)
1783 {
1784     generic_4_byte( X_GLrop_Vertex2sv, v );
1785 }
1786
1787 #define X_GLrop_Vertex3dv 69
1788 void
1789 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
1790 {
1791     __GLXcontext * const gc = __glXGetCurrentContext();
1792     const GLuint cmdlen = 28;
1793     emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
1794     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1795     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1796     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1797     gc->pc += cmdlen;
1798     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1799 }
1800
1801 #define X_GLrop_Vertex3dv 69
1802 void
1803 __indirect_glVertex3dv(const GLdouble * v)
1804 {
1805     generic_24_byte( X_GLrop_Vertex3dv, v );
1806 }
1807
1808 #define X_GLrop_Vertex3fv 70
1809 void
1810 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
1811 {
1812     __GLXcontext * const gc = __glXGetCurrentContext();
1813     const GLuint cmdlen = 16;
1814     emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
1815     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1816     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1817     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1818     gc->pc += cmdlen;
1819     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1820 }
1821
1822 #define X_GLrop_Vertex3fv 70
1823 void
1824 __indirect_glVertex3fv(const GLfloat * v)
1825 {
1826     generic_12_byte( X_GLrop_Vertex3fv, v );
1827 }
1828
1829 #define X_GLrop_Vertex3iv 71
1830 void
1831 __indirect_glVertex3i(GLint x, GLint y, GLint z)
1832 {
1833     __GLXcontext * const gc = __glXGetCurrentContext();
1834     const GLuint cmdlen = 16;
1835     emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
1836     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1837     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1838     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1839     gc->pc += cmdlen;
1840     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1841 }
1842
1843 #define X_GLrop_Vertex3iv 71
1844 void
1845 __indirect_glVertex3iv(const GLint * v)
1846 {
1847     generic_12_byte( X_GLrop_Vertex3iv, v );
1848 }
1849
1850 #define X_GLrop_Vertex3sv 72
1851 void
1852 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
1853 {
1854     __GLXcontext * const gc = __glXGetCurrentContext();
1855     const GLuint cmdlen = 12;
1856     emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
1857     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1858     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1859     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1860     gc->pc += cmdlen;
1861     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1862 }
1863
1864 #define X_GLrop_Vertex3sv 72
1865 void
1866 __indirect_glVertex3sv(const GLshort * v)
1867 {
1868     generic_6_byte( X_GLrop_Vertex3sv, v );
1869 }
1870
1871 #define X_GLrop_Vertex4dv 73
1872 void
1873 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1874 {
1875     __GLXcontext * const gc = __glXGetCurrentContext();
1876     const GLuint cmdlen = 36;
1877     emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
1878     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1879     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1880     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1881     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1882     gc->pc += cmdlen;
1883     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1884 }
1885
1886 #define X_GLrop_Vertex4dv 73
1887 void
1888 __indirect_glVertex4dv(const GLdouble * v)
1889 {
1890     generic_32_byte( X_GLrop_Vertex4dv, v );
1891 }
1892
1893 #define X_GLrop_Vertex4fv 74
1894 void
1895 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1896 {
1897     __GLXcontext * const gc = __glXGetCurrentContext();
1898     const GLuint cmdlen = 20;
1899     emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
1900     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1901     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1902     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1903     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1904     gc->pc += cmdlen;
1905     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1906 }
1907
1908 #define X_GLrop_Vertex4fv 74
1909 void
1910 __indirect_glVertex4fv(const GLfloat * v)
1911 {
1912     generic_16_byte( X_GLrop_Vertex4fv, v );
1913 }
1914
1915 #define X_GLrop_Vertex4iv 75
1916 void
1917 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
1918 {
1919     __GLXcontext * const gc = __glXGetCurrentContext();
1920     const GLuint cmdlen = 20;
1921     emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
1922     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1923     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1924     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1925     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1926     gc->pc += cmdlen;
1927     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1928 }
1929
1930 #define X_GLrop_Vertex4iv 75
1931 void
1932 __indirect_glVertex4iv(const GLint * v)
1933 {
1934     generic_16_byte( X_GLrop_Vertex4iv, v );
1935 }
1936
1937 #define X_GLrop_Vertex4sv 76
1938 void
1939 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
1940 {
1941     __GLXcontext * const gc = __glXGetCurrentContext();
1942     const GLuint cmdlen = 12;
1943     emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
1944     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1945     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1946     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1947     (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1948     gc->pc += cmdlen;
1949     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1950 }
1951
1952 #define X_GLrop_Vertex4sv 76
1953 void
1954 __indirect_glVertex4sv(const GLshort * v)
1955 {
1956     generic_8_byte( X_GLrop_Vertex4sv, v );
1957 }
1958
1959 #define X_GLrop_ClipPlane 77
1960 void
1961 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
1962 {
1963     __GLXcontext * const gc = __glXGetCurrentContext();
1964     const GLuint cmdlen = 40;
1965     emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
1966     (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
1967     (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
1968     gc->pc += cmdlen;
1969     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1970 }
1971
1972 #define X_GLrop_ColorMaterial 78
1973 void
1974 __indirect_glColorMaterial(GLenum face, GLenum mode)
1975 {
1976     __GLXcontext * const gc = __glXGetCurrentContext();
1977     const GLuint cmdlen = 12;
1978     emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
1979     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
1980     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
1981     gc->pc += cmdlen;
1982     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1983 }
1984
1985 #define X_GLrop_CullFace 79
1986 void
1987 __indirect_glCullFace(GLenum mode)
1988 {
1989     __GLXcontext * const gc = __glXGetCurrentContext();
1990     const GLuint cmdlen = 8;
1991     emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
1992     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
1993     gc->pc += cmdlen;
1994     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1995 }
1996
1997 #define X_GLrop_Fogf 80
1998 void
1999 __indirect_glFogf(GLenum pname, GLfloat param)
2000 {
2001     __GLXcontext * const gc = __glXGetCurrentContext();
2002     const GLuint cmdlen = 12;
2003     emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
2004     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2005     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2006     gc->pc += cmdlen;
2007     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2008 }
2009
2010 #define X_GLrop_Fogfv 81
2011 void
2012 __indirect_glFogfv(GLenum pname, const GLfloat * params)
2013 {
2014     __GLXcontext * const gc = __glXGetCurrentContext();
2015     const GLuint compsize = __glFogfv_size(pname);
2016     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2017     emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
2018     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2019     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2020     gc->pc += cmdlen;
2021     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2022 }
2023
2024 #define X_GLrop_Fogi 82
2025 void
2026 __indirect_glFogi(GLenum pname, GLint param)
2027 {
2028     __GLXcontext * const gc = __glXGetCurrentContext();
2029     const GLuint cmdlen = 12;
2030     emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
2031     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2032     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2033     gc->pc += cmdlen;
2034     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2035 }
2036
2037 #define X_GLrop_Fogiv 83
2038 void
2039 __indirect_glFogiv(GLenum pname, const GLint * params)
2040 {
2041     __GLXcontext * const gc = __glXGetCurrentContext();
2042     const GLuint compsize = __glFogiv_size(pname);
2043     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2044     emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
2045     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2046     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2047     gc->pc += cmdlen;
2048     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2049 }
2050
2051 #define X_GLrop_FrontFace 84
2052 void
2053 __indirect_glFrontFace(GLenum mode)
2054 {
2055     __GLXcontext * const gc = __glXGetCurrentContext();
2056     const GLuint cmdlen = 8;
2057     emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
2058     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2059     gc->pc += cmdlen;
2060     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2061 }
2062
2063 #define X_GLrop_Hint 85
2064 void
2065 __indirect_glHint(GLenum target, GLenum mode)
2066 {
2067     __GLXcontext * const gc = __glXGetCurrentContext();
2068     const GLuint cmdlen = 12;
2069     emit_header(gc->pc, X_GLrop_Hint, cmdlen);
2070     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2071     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2072     gc->pc += cmdlen;
2073     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2074 }
2075
2076 #define X_GLrop_Lightf 86
2077 void
2078 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
2079 {
2080     __GLXcontext * const gc = __glXGetCurrentContext();
2081     const GLuint cmdlen = 16;
2082     emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
2083     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2084     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2085     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2086     gc->pc += cmdlen;
2087     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2088 }
2089
2090 #define X_GLrop_Lightfv 87
2091 void
2092 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
2093 {
2094     __GLXcontext * const gc = __glXGetCurrentContext();
2095     const GLuint compsize = __glLightfv_size(pname);
2096     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2097     emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
2098     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2099     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2100     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2101     gc->pc += cmdlen;
2102     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2103 }
2104
2105 #define X_GLrop_Lighti 88
2106 void
2107 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2108 {
2109     __GLXcontext * const gc = __glXGetCurrentContext();
2110     const GLuint cmdlen = 16;
2111     emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2112     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2113     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2114     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2115     gc->pc += cmdlen;
2116     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2117 }
2118
2119 #define X_GLrop_Lightiv 89
2120 void
2121 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2122 {
2123     __GLXcontext * const gc = __glXGetCurrentContext();
2124     const GLuint compsize = __glLightiv_size(pname);
2125     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2126     emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2127     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2128     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2129     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2130     gc->pc += cmdlen;
2131     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2132 }
2133
2134 #define X_GLrop_LightModelf 90
2135 void
2136 __indirect_glLightModelf(GLenum pname, GLfloat param)
2137 {
2138     __GLXcontext * const gc = __glXGetCurrentContext();
2139     const GLuint cmdlen = 12;
2140     emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2141     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2142     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2143     gc->pc += cmdlen;
2144     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2145 }
2146
2147 #define X_GLrop_LightModelfv 91
2148 void
2149 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2150 {
2151     __GLXcontext * const gc = __glXGetCurrentContext();
2152     const GLuint compsize = __glLightModelfv_size(pname);
2153     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2154     emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2155     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2156     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2157     gc->pc += cmdlen;
2158     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2159 }
2160
2161 #define X_GLrop_LightModeli 92
2162 void
2163 __indirect_glLightModeli(GLenum pname, GLint param)
2164 {
2165     __GLXcontext * const gc = __glXGetCurrentContext();
2166     const GLuint cmdlen = 12;
2167     emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2168     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2169     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2170     gc->pc += cmdlen;
2171     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2172 }
2173
2174 #define X_GLrop_LightModeliv 93
2175 void
2176 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2177 {
2178     __GLXcontext * const gc = __glXGetCurrentContext();
2179     const GLuint compsize = __glLightModeliv_size(pname);
2180     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2181     emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2182     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2183     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2184     gc->pc += cmdlen;
2185     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2186 }
2187
2188 #define X_GLrop_LineStipple 94
2189 void
2190 __indirect_glLineStipple(GLint factor, GLushort pattern)
2191 {
2192     __GLXcontext * const gc = __glXGetCurrentContext();
2193     const GLuint cmdlen = 12;
2194     emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2195     (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
2196     (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
2197     gc->pc += cmdlen;
2198     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2199 }
2200
2201 #define X_GLrop_LineWidth 95
2202 void
2203 __indirect_glLineWidth(GLfloat width)
2204 {
2205     __GLXcontext * const gc = __glXGetCurrentContext();
2206     const GLuint cmdlen = 8;
2207     emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2208     (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
2209     gc->pc += cmdlen;
2210     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2211 }
2212
2213 #define X_GLrop_Materialf 96
2214 void
2215 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2216 {
2217     __GLXcontext * const gc = __glXGetCurrentContext();
2218     const GLuint cmdlen = 16;
2219     emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2220     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2221     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2222     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2223     gc->pc += cmdlen;
2224     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2225 }
2226
2227 #define X_GLrop_Materialfv 97
2228 void
2229 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2230 {
2231     __GLXcontext * const gc = __glXGetCurrentContext();
2232     const GLuint compsize = __glMaterialfv_size(pname);
2233     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2234     emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2235     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2236     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2237     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2238     gc->pc += cmdlen;
2239     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2240 }
2241
2242 #define X_GLrop_Materiali 98
2243 void
2244 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2245 {
2246     __GLXcontext * const gc = __glXGetCurrentContext();
2247     const GLuint cmdlen = 16;
2248     emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2249     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2250     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2251     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2252     gc->pc += cmdlen;
2253     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2254 }
2255
2256 #define X_GLrop_Materialiv 99
2257 void
2258 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2259 {
2260     __GLXcontext * const gc = __glXGetCurrentContext();
2261     const GLuint compsize = __glMaterialiv_size(pname);
2262     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2263     emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2264     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2265     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2266     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2267     gc->pc += cmdlen;
2268     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2269 }
2270
2271 #define X_GLrop_PointSize 100
2272 void
2273 __indirect_glPointSize(GLfloat size)
2274 {
2275     __GLXcontext * const gc = __glXGetCurrentContext();
2276     const GLuint cmdlen = 8;
2277     emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2278     (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
2279     gc->pc += cmdlen;
2280     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2281 }
2282
2283 #define X_GLrop_PolygonMode 101
2284 void
2285 __indirect_glPolygonMode(GLenum face, GLenum mode)
2286 {
2287     __GLXcontext * const gc = __glXGetCurrentContext();
2288     const GLuint cmdlen = 12;
2289     emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2290     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2291     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2292     gc->pc += cmdlen;
2293     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2294 }
2295
2296 #define X_GLrop_PolygonStipple 102
2297 void
2298 __indirect_glPolygonStipple(const GLubyte * mask)
2299 {
2300     __GLXcontext * const gc = __glXGetCurrentContext();
2301     const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
2302     const GLuint cmdlen = 24 + __GLX_PAD(compsize);
2303     emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
2304     if (compsize > 0) {
2305         (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4);
2306     }
2307     else {
2308         (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
2309     }
2310     gc->pc += cmdlen;
2311     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2312 }
2313
2314 #define X_GLrop_Scissor 103
2315 void
2316 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2317 {
2318     __GLXcontext * const gc = __glXGetCurrentContext();
2319     const GLuint cmdlen = 20;
2320     emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2321     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
2322     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
2323     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
2324     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
2325     gc->pc += cmdlen;
2326     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2327 }
2328
2329 #define X_GLrop_ShadeModel 104
2330 void
2331 __indirect_glShadeModel(GLenum mode)
2332 {
2333     __GLXcontext * const gc = __glXGetCurrentContext();
2334     const GLuint cmdlen = 8;
2335     emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2336     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2337     gc->pc += cmdlen;
2338     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2339 }
2340
2341 #define X_GLrop_TexParameterf 105
2342 void
2343 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2344 {
2345     __GLXcontext * const gc = __glXGetCurrentContext();
2346     const GLuint cmdlen = 16;
2347     emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2348     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2349     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2350     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2351     gc->pc += cmdlen;
2352     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2353 }
2354
2355 #define X_GLrop_TexParameterfv 106
2356 void
2357 __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
2358 {
2359     __GLXcontext * const gc = __glXGetCurrentContext();
2360     const GLuint compsize = __glTexParameterfv_size(pname);
2361     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2362     emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2363     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2364     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2365     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2366     gc->pc += cmdlen;
2367     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2368 }
2369
2370 #define X_GLrop_TexParameteri 107
2371 void
2372 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2373 {
2374     __GLXcontext * const gc = __glXGetCurrentContext();
2375     const GLuint cmdlen = 16;
2376     emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2377     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2378     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2379     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2380     gc->pc += cmdlen;
2381     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2382 }
2383
2384 #define X_GLrop_TexParameteriv 108
2385 void
2386 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2387 {
2388     __GLXcontext * const gc = __glXGetCurrentContext();
2389     const GLuint compsize = __glTexParameteriv_size(pname);
2390     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2391     emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2392     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2393     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2394     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2395     gc->pc += cmdlen;
2396     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2397 }
2398
2399 static void
2400 __glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
2401 {
2402     __GLXcontext * const gc = __glXGetCurrentContext();
2403     const GLuint compsize = __glImageSize(width, height, 1, format, type, target);
2404     const GLuint cmdlen = 56 + __GLX_PAD(compsize);
2405     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
2406         if (cmdlen <= gc->maxSmallRenderCommandSize) {
2407             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
2408                 (void) __glXFlushRenderBuffer(gc, gc->pc);
2409             }
2410             emit_header(gc->pc, opcode, cmdlen);
2411             (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
2412             (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
2413             (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4);
2414             (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4);
2415             (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4);
2416             (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4);
2417             (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
2418             (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
2419             if ((compsize > 0) && (pixels != NULL)) {
2420                 (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4);
2421             }
2422             else {
2423                 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
2424             }
2425             gc->pc += cmdlen;
2426             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2427         }
2428         else {
2429             const GLint op = opcode;
2430             const GLuint cmdlenLarge = cmdlen + 4;
2431             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
2432             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
2433             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
2434             (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
2435             (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
2436             (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4);
2437             (void) memcpy((void *)(pc + 40), (void *)(&width), 4);
2438             (void) memcpy((void *)(pc + 44), (void *)(&height), 4);
2439             (void) memcpy((void *)(pc + 48), (void *)(&border), 4);
2440             (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
2441             (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
2442             __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8);
2443         }
2444     }
2445 }
2446
2447 #define X_GLrop_TexImage1D 109
2448 void
2449 __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
2450 {
2451     __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels );
2452 }
2453
2454 #define X_GLrop_TexImage2D 110
2455 void
2456 __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
2457 {
2458     __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels );
2459 }
2460
2461 #define X_GLrop_TexEnvf 111
2462 void
2463 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2464 {
2465     __GLXcontext * const gc = __glXGetCurrentContext();
2466     const GLuint cmdlen = 16;
2467     emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2468     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2469     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2470     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2471     gc->pc += cmdlen;
2472     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2473 }
2474
2475 #define X_GLrop_TexEnvfv 112
2476 void
2477 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2478 {
2479     __GLXcontext * const gc = __glXGetCurrentContext();
2480     const GLuint compsize = __glTexEnvfv_size(pname);
2481     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2482     emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2483     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2484     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2485     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2486     gc->pc += cmdlen;
2487     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2488 }
2489
2490 #define X_GLrop_TexEnvi 113
2491 void
2492 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2493 {
2494     __GLXcontext * const gc = __glXGetCurrentContext();
2495     const GLuint cmdlen = 16;
2496     emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2497     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2498     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2499     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2500     gc->pc += cmdlen;
2501     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2502 }
2503
2504 #define X_GLrop_TexEnviv 114
2505 void
2506 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2507 {
2508     __GLXcontext * const gc = __glXGetCurrentContext();
2509     const GLuint compsize = __glTexEnviv_size(pname);
2510     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2511     emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2512     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2513     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2514     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2515     gc->pc += cmdlen;
2516     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2517 }
2518
2519 #define X_GLrop_TexGend 115
2520 void
2521 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2522 {
2523     __GLXcontext * const gc = __glXGetCurrentContext();
2524     const GLuint cmdlen = 20;
2525     emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2526     (void) memcpy((void *)(gc->pc + 4), (void *)(&param), 8);
2527     (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
2528     (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
2529     gc->pc += cmdlen;
2530     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2531 }
2532
2533 #define X_GLrop_TexGendv 116
2534 void
2535 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2536 {
2537     __GLXcontext * const gc = __glXGetCurrentContext();
2538     const GLuint compsize = __glTexGendv_size(pname);
2539     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2540     emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2541     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2542     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2543     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
2544     gc->pc += cmdlen;
2545     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2546 }
2547
2548 #define X_GLrop_TexGenf 117
2549 void
2550 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2551 {
2552     __GLXcontext * const gc = __glXGetCurrentContext();
2553     const GLuint cmdlen = 16;
2554     emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2555     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2556     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2557     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2558     gc->pc += cmdlen;
2559     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2560 }
2561
2562 #define X_GLrop_TexGenfv 118
2563 void
2564 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2565 {
2566     __GLXcontext * const gc = __glXGetCurrentContext();
2567     const GLuint compsize = __glTexGenfv_size(pname);
2568     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2569     emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2570     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2571     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2572     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2573     gc->pc += cmdlen;
2574     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2575 }
2576
2577 #define X_GLrop_TexGeni 119
2578 void
2579 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2580 {
2581     __GLXcontext * const gc = __glXGetCurrentContext();
2582     const GLuint cmdlen = 16;
2583     emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2584     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2585     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2586     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2587     gc->pc += cmdlen;
2588     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2589 }
2590
2591 #define X_GLrop_TexGeniv 120
2592 void
2593 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2594 {
2595     __GLXcontext * const gc = __glXGetCurrentContext();
2596     const GLuint compsize = __glTexGeniv_size(pname);
2597     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2598     emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2599     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2600     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2601     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2602     gc->pc += cmdlen;
2603     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2604 }
2605
2606 #define X_GLrop_InitNames 121
2607 void
2608 __indirect_glInitNames(void)
2609 {
2610     __GLXcontext * const gc = __glXGetCurrentContext();
2611     const GLuint cmdlen = 4;
2612     emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2613     gc->pc += cmdlen;
2614     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2615 }
2616
2617 #define X_GLrop_LoadName 122
2618 void
2619 __indirect_glLoadName(GLuint name)
2620 {
2621     __GLXcontext * const gc = __glXGetCurrentContext();
2622     const GLuint cmdlen = 8;
2623     emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2624     (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2625     gc->pc += cmdlen;
2626     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2627 }
2628
2629 #define X_GLrop_PassThrough 123
2630 void
2631 __indirect_glPassThrough(GLfloat token)
2632 {
2633     __GLXcontext * const gc = __glXGetCurrentContext();
2634     const GLuint cmdlen = 8;
2635     emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2636     (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
2637     gc->pc += cmdlen;
2638     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2639 }
2640
2641 #define X_GLrop_PopName 124
2642 void
2643 __indirect_glPopName(void)
2644 {
2645     __GLXcontext * const gc = __glXGetCurrentContext();
2646     const GLuint cmdlen = 4;
2647     emit_header(gc->pc, X_GLrop_PopName, cmdlen);
2648     gc->pc += cmdlen;
2649     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2650 }
2651
2652 #define X_GLrop_PushName 125
2653 void
2654 __indirect_glPushName(GLuint name)
2655 {
2656     __GLXcontext * const gc = __glXGetCurrentContext();
2657     const GLuint cmdlen = 8;
2658     emit_header(gc->pc, X_GLrop_PushName, cmdlen);
2659     (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2660     gc->pc += cmdlen;
2661     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2662 }
2663
2664 #define X_GLrop_DrawBuffer 126
2665 void
2666 __indirect_glDrawBuffer(GLenum mode)
2667 {
2668     __GLXcontext * const gc = __glXGetCurrentContext();
2669     const GLuint cmdlen = 8;
2670     emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
2671     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2672     gc->pc += cmdlen;
2673     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2674 }
2675
2676 #define X_GLrop_Clear 127
2677 void
2678 __indirect_glClear(GLbitfield mask)
2679 {
2680     __GLXcontext * const gc = __glXGetCurrentContext();
2681     const GLuint cmdlen = 8;
2682     emit_header(gc->pc, X_GLrop_Clear, cmdlen);
2683     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2684     gc->pc += cmdlen;
2685     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2686 }
2687
2688 #define X_GLrop_ClearAccum 128
2689 void
2690 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
2691 {
2692     __GLXcontext * const gc = __glXGetCurrentContext();
2693     const GLuint cmdlen = 20;
2694     emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
2695     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2696     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2697     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2698     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2699     gc->pc += cmdlen;
2700     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2701 }
2702
2703 #define X_GLrop_ClearIndex 129
2704 void
2705 __indirect_glClearIndex(GLfloat c)
2706 {
2707     __GLXcontext * const gc = __glXGetCurrentContext();
2708     const GLuint cmdlen = 8;
2709     emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
2710     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
2711     gc->pc += cmdlen;
2712     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2713 }
2714
2715 #define X_GLrop_ClearColor 130
2716 void
2717 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
2718 {
2719     __GLXcontext * const gc = __glXGetCurrentContext();
2720     const GLuint cmdlen = 20;
2721     emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
2722     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2723     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2724     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2725     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2726     gc->pc += cmdlen;
2727     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2728 }
2729
2730 #define X_GLrop_ClearStencil 131
2731 void
2732 __indirect_glClearStencil(GLint s)
2733 {
2734     __GLXcontext * const gc = __glXGetCurrentContext();
2735     const GLuint cmdlen = 8;
2736     emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
2737     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
2738     gc->pc += cmdlen;
2739     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2740 }
2741
2742 #define X_GLrop_ClearDepth 132
2743 void
2744 __indirect_glClearDepth(GLclampd depth)
2745 {
2746     __GLXcontext * const gc = __glXGetCurrentContext();
2747     const GLuint cmdlen = 12;
2748     emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
2749     (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
2750     gc->pc += cmdlen;
2751     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2752 }
2753
2754 #define X_GLrop_StencilMask 133
2755 void
2756 __indirect_glStencilMask(GLuint mask)
2757 {
2758     __GLXcontext * const gc = __glXGetCurrentContext();
2759     const GLuint cmdlen = 8;
2760     emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
2761     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2762     gc->pc += cmdlen;
2763     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2764 }
2765
2766 #define X_GLrop_ColorMask 134
2767 void
2768 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
2769 {
2770     __GLXcontext * const gc = __glXGetCurrentContext();
2771     const GLuint cmdlen = 8;
2772     emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
2773     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
2774     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
2775     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
2776     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
2777     gc->pc += cmdlen;
2778     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2779 }
2780
2781 #define X_GLrop_DepthMask 135
2782 void
2783 __indirect_glDepthMask(GLboolean flag)
2784 {
2785     __GLXcontext * const gc = __glXGetCurrentContext();
2786     const GLuint cmdlen = 8;
2787     emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
2788     (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
2789     gc->pc += cmdlen;
2790     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2791 }
2792
2793 #define X_GLrop_IndexMask 136
2794 void
2795 __indirect_glIndexMask(GLuint mask)
2796 {
2797     __GLXcontext * const gc = __glXGetCurrentContext();
2798     const GLuint cmdlen = 8;
2799     emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
2800     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2801     gc->pc += cmdlen;
2802     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2803 }
2804
2805 #define X_GLrop_Accum 137
2806 void
2807 __indirect_glAccum(GLenum op, GLfloat value)
2808 {
2809     __GLXcontext * const gc = __glXGetCurrentContext();
2810     const GLuint cmdlen = 12;
2811     emit_header(gc->pc, X_GLrop_Accum, cmdlen);
2812     (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
2813     (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
2814     gc->pc += cmdlen;
2815     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2816 }
2817
2818 #define X_GLrop_PopAttrib 141
2819 void
2820 __indirect_glPopAttrib(void)
2821 {
2822     __GLXcontext * const gc = __glXGetCurrentContext();
2823     const GLuint cmdlen = 4;
2824     emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
2825     gc->pc += cmdlen;
2826     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2827 }
2828
2829 #define X_GLrop_PushAttrib 142
2830 void
2831 __indirect_glPushAttrib(GLbitfield mask)
2832 {
2833     __GLXcontext * const gc = __glXGetCurrentContext();
2834     const GLuint cmdlen = 8;
2835     emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
2836     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2837     gc->pc += cmdlen;
2838     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2839 }
2840
2841 #define X_GLrop_MapGrid1d 147
2842 void
2843 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2844 {
2845     __GLXcontext * const gc = __glXGetCurrentContext();
2846     const GLuint cmdlen = 24;
2847     emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
2848     (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2849     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2850     (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
2851     gc->pc += cmdlen;
2852     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2853 }
2854
2855 #define X_GLrop_MapGrid1f 148
2856 void
2857 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2858 {
2859     __GLXcontext * const gc = __glXGetCurrentContext();
2860     const GLuint cmdlen = 16;
2861     emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
2862     (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2863     (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2864     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2865     gc->pc += cmdlen;
2866     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2867 }
2868
2869 #define X_GLrop_MapGrid2d 149
2870 void
2871 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
2872 {
2873     __GLXcontext * const gc = __glXGetCurrentContext();
2874     const GLuint cmdlen = 44;
2875     emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
2876     (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2877     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2878     (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
2879     (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
2880     (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
2881     (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
2882     gc->pc += cmdlen;
2883     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2884 }
2885
2886 #define X_GLrop_MapGrid2f 150
2887 void
2888 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
2889 {
2890     __GLXcontext * const gc = __glXGetCurrentContext();
2891     const GLuint cmdlen = 28;
2892     emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
2893     (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2894     (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2895     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2896     (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
2897     (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
2898     (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
2899     gc->pc += cmdlen;
2900     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2901 }
2902
2903 #define X_GLrop_EvalCoord1dv 151
2904 void
2905 __indirect_glEvalCoord1d(GLdouble u)
2906 {
2907     __GLXcontext * const gc = __glXGetCurrentContext();
2908     const GLuint cmdlen = 12;
2909     emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
2910     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
2911     gc->pc += cmdlen;
2912     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2913 }
2914
2915 #define X_GLrop_EvalCoord1dv 151
2916 void
2917 __indirect_glEvalCoord1dv(const GLdouble * u)
2918 {
2919     generic_8_byte( X_GLrop_EvalCoord1dv, u );
2920 }
2921
2922 #define X_GLrop_EvalCoord1fv 152
2923 void
2924 __indirect_glEvalCoord1f(GLfloat u)
2925 {
2926     __GLXcontext * const gc = __glXGetCurrentContext();
2927     const GLuint cmdlen = 8;
2928     emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
2929     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
2930     gc->pc += cmdlen;
2931     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2932 }
2933
2934 #define X_GLrop_EvalCoord1fv 152
2935 void
2936 __indirect_glEvalCoord1fv(const GLfloat * u)
2937 {
2938     generic_4_byte( X_GLrop_EvalCoord1fv, u );
2939 }
2940
2941 #define X_GLrop_EvalCoord2dv 153
2942 void
2943 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
2944 {
2945     __GLXcontext * const gc = __glXGetCurrentContext();
2946     const GLuint cmdlen = 20;
2947     emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
2948     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
2949     (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
2950     gc->pc += cmdlen;
2951     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2952 }
2953
2954 #define X_GLrop_EvalCoord2dv 153
2955 void
2956 __indirect_glEvalCoord2dv(const GLdouble * u)
2957 {
2958     generic_16_byte( X_GLrop_EvalCoord2dv, u );
2959 }
2960
2961 #define X_GLrop_EvalCoord2fv 154
2962 void
2963 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
2964 {
2965     __GLXcontext * const gc = __glXGetCurrentContext();
2966     const GLuint cmdlen = 12;
2967     emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
2968     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
2969     (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
2970     gc->pc += cmdlen;
2971     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2972 }
2973
2974 #define X_GLrop_EvalCoord2fv 154
2975 void
2976 __indirect_glEvalCoord2fv(const GLfloat * u)
2977 {
2978     generic_8_byte( X_GLrop_EvalCoord2fv, u );
2979 }
2980
2981 #define X_GLrop_EvalMesh1 155
2982 void
2983 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
2984 {
2985     __GLXcontext * const gc = __glXGetCurrentContext();
2986     const GLuint cmdlen = 16;
2987     emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
2988     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2989     (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
2990     (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
2991     gc->pc += cmdlen;
2992     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2993 }
2994
2995 #define X_GLrop_EvalPoint1 156
2996 void
2997 __indirect_glEvalPoint1(GLint i)
2998 {
2999     __GLXcontext * const gc = __glXGetCurrentContext();
3000     const GLuint cmdlen = 8;
3001     emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
3002     (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
3003     gc->pc += cmdlen;
3004     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3005 }
3006
3007 #define X_GLrop_EvalMesh2 157
3008 void
3009 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
3010 {
3011     __GLXcontext * const gc = __glXGetCurrentContext();
3012     const GLuint cmdlen = 24;
3013     emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
3014     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3015     (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
3016     (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
3017     (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
3018     (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
3019     gc->pc += cmdlen;
3020     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3021 }
3022
3023 #define X_GLrop_EvalPoint2 158
3024 void
3025 __indirect_glEvalPoint2(GLint i, GLint j)
3026 {
3027     __GLXcontext * const gc = __glXGetCurrentContext();
3028     const GLuint cmdlen = 12;
3029     emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
3030     (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
3031     (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
3032     gc->pc += cmdlen;
3033     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3034 }
3035
3036 #define X_GLrop_AlphaFunc 159
3037 void
3038 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
3039 {
3040     __GLXcontext * const gc = __glXGetCurrentContext();
3041     const GLuint cmdlen = 12;
3042     emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
3043     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3044     (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
3045     gc->pc += cmdlen;
3046     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3047 }
3048
3049 #define X_GLrop_BlendFunc 160
3050 void
3051 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
3052 {
3053     __GLXcontext * const gc = __glXGetCurrentContext();
3054     const GLuint cmdlen = 12;
3055     emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
3056     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
3057     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
3058     gc->pc += cmdlen;
3059     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3060 }
3061
3062 #define X_GLrop_LogicOp 161
3063 void
3064 __indirect_glLogicOp(GLenum opcode)
3065 {
3066     __GLXcontext * const gc = __glXGetCurrentContext();
3067     const GLuint cmdlen = 8;
3068     emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
3069     (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
3070     gc->pc += cmdlen;
3071     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3072 }
3073
3074 #define X_GLrop_StencilFunc 162
3075 void
3076 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3077 {
3078     __GLXcontext * const gc = __glXGetCurrentContext();
3079     const GLuint cmdlen = 16;
3080     emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
3081     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3082     (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
3083     (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
3084     gc->pc += cmdlen;
3085     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3086 }
3087
3088 #define X_GLrop_StencilOp 163
3089 void
3090 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3091 {
3092     __GLXcontext * const gc = __glXGetCurrentContext();
3093     const GLuint cmdlen = 16;
3094     emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
3095     (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
3096     (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
3097     (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
3098     gc->pc += cmdlen;
3099     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3100 }
3101
3102 #define X_GLrop_DepthFunc 164
3103 void
3104 __indirect_glDepthFunc(GLenum func)
3105 {
3106     __GLXcontext * const gc = __glXGetCurrentContext();
3107     const GLuint cmdlen = 8;
3108     emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
3109     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3110     gc->pc += cmdlen;
3111     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3112 }
3113
3114 #define X_GLrop_PixelZoom 165
3115 void
3116 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
3117 {
3118     __GLXcontext * const gc = __glXGetCurrentContext();
3119     const GLuint cmdlen = 12;
3120     emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
3121     (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
3122     (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
3123     gc->pc += cmdlen;
3124     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3125 }
3126
3127 #define X_GLrop_PixelTransferf 166
3128 void
3129 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
3130 {
3131     __GLXcontext * const gc = __glXGetCurrentContext();
3132     const GLuint cmdlen = 12;
3133     emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
3134     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
3135     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
3136     gc->pc += cmdlen;
3137     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3138 }
3139
3140 #define X_GLrop_PixelTransferi 167
3141 void
3142 __indirect_glPixelTransferi(GLenum pname, GLint param)
3143 {
3144     __GLXcontext * const gc = __glXGetCurrentContext();
3145     const GLuint cmdlen = 12;
3146     emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
3147     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
3148     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
3149     gc->pc += cmdlen;
3150     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3151 }
3152
3153 #define X_GLrop_PixelMapfv 168
3154 void
3155 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
3156 {
3157     __GLXcontext * const gc = __glXGetCurrentContext();
3158     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3159     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3160         if (cmdlen <= gc->maxSmallRenderCommandSize) {
3161             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3162                 (void) __glXFlushRenderBuffer(gc, gc->pc);
3163             }
3164             emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
3165             (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3166             (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3167             (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3168             gc->pc += cmdlen;
3169             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3170         }
3171         else {
3172             const GLint op = X_GLrop_PixelMapfv;
3173             const GLuint cmdlenLarge = cmdlen + 4;
3174             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3175             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3176             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3177             (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3178             (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3179             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3180         }
3181     }
3182 }
3183
3184 #define X_GLrop_PixelMapuiv 169
3185 void
3186 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3187 {
3188     __GLXcontext * const gc = __glXGetCurrentContext();
3189     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3190     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3191         if (cmdlen <= gc->maxSmallRenderCommandSize) {
3192             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3193                 (void) __glXFlushRenderBuffer(gc, gc->pc);
3194             }
3195             emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3196             (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3197             (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3198             (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3199             gc->pc += cmdlen;
3200             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3201         }
3202         else {
3203             const GLint op = X_GLrop_PixelMapuiv;
3204             const GLuint cmdlenLarge = cmdlen + 4;
3205             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3206             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3207             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3208             (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3209             (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3210             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3211         }
3212     }
3213 }
3214
3215 #define X_GLrop_PixelMapusv 170
3216 void
3217 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3218 {
3219     __GLXcontext * const gc = __glXGetCurrentContext();
3220     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3221     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3222         if (cmdlen <= gc->maxSmallRenderCommandSize) {
3223             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3224                 (void) __glXFlushRenderBuffer(gc, gc->pc);
3225             }
3226             emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3227             (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3228             (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3229             (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
3230             gc->pc += cmdlen;
3231             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3232         }
3233         else {
3234             const GLint op = X_GLrop_PixelMapusv;
3235             const GLuint cmdlenLarge = cmdlen + 4;
3236             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3237             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3238             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3239             (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3240             (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3241             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
3242         }
3243     }
3244 }
3245
3246 #define X_GLrop_ReadBuffer 171
3247 void
3248 __indirect_glReadBuffer(GLenum mode)
3249 {
3250     __GLXcontext * const gc = __glXGetCurrentContext();
3251     const GLuint cmdlen = 8;
3252     emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3253     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3254     gc->pc += cmdlen;
3255     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3256 }
3257
3258 #define X_GLrop_CopyPixels 172
3259 void
3260 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
3261 {
3262     __GLXcontext * const gc = __glXGetCurrentContext();
3263     const GLuint cmdlen = 24;
3264     emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3265     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3266     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3267     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3268     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3269     (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
3270     gc->pc += cmdlen;
3271     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3272 }
3273
3274 #define X_GLsop_ReadPixels 111
3275 void
3276 __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
3277 {
3278     __GLXcontext * const gc = __glXGetCurrentContext();
3279     const __GLXattribute * const state = gc->client_state_private;
3280     Display * const dpy = gc->currentDpy;
3281     const GLuint cmdlen = 28;
3282     if (__builtin_expect(dpy != NULL, 1)) {
3283         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
3284         (void) memcpy((void *)(pc + 0), (void *)(&x), 4);
3285         (void) memcpy((void *)(pc + 4), (void *)(&y), 4);
3286         (void) memcpy((void *)(pc + 8), (void *)(&width), 4);
3287         (void) memcpy((void *)(pc + 12), (void *)(&height), 4);
3288         (void) memcpy((void *)(pc + 16), (void *)(&format), 4);
3289         (void) memcpy((void *)(pc + 20), (void *)(&type), 4);
3290         *(int32_t *)(pc + 24) = 0;
3291         * (int8_t *)(pc + 24) = state->storePack.swapEndian;
3292         __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE);
3293         UnlockDisplay(dpy); SyncHandle();
3294     }
3295     return;
3296 }
3297
3298 #define X_GLrop_DrawPixels 173
3299 void
3300 __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
3301 {
3302     __GLXcontext * const gc = __glXGetCurrentContext();
3303     const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0;
3304     const GLuint cmdlen = 40 + __GLX_PAD(compsize);
3305     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
3306         if (cmdlen <= gc->maxSmallRenderCommandSize) {
3307             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3308                 (void) __glXFlushRenderBuffer(gc, gc->pc);
3309             }
3310             emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
3311             (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
3312             (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
3313             (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4);
3314             (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4);
3315             if (compsize > 0) {
3316                 (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4);
3317             }
3318             else {
3319                 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
3320             }
3321             gc->pc += cmdlen;
3322             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3323         }
3324         else {
3325             const GLint op = X_GLrop_DrawPixels;
3326             const GLuint cmdlenLarge = cmdlen + 4;
3327             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3328             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3329             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3330             (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
3331             (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
3332             (void) memcpy((void *)(pc + 36), (void *)(&format), 4);
3333             (void) memcpy((void *)(pc + 40), (void *)(&type), 4);
3334             __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8);
3335         }
3336     }
3337 }
3338
3339 #define X_GLsop_GetClipPlane 113
3340 void
3341 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3342 {
3343     __GLXcontext * const gc = __glXGetCurrentContext();
3344     Display * const dpy = gc->currentDpy;
3345     const GLuint cmdlen = 4;
3346     if (__builtin_expect(dpy != NULL, 1)) {
3347         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
3348         (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
3349         (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
3350         UnlockDisplay(dpy); SyncHandle();
3351     }
3352     return;
3353 }
3354
3355 #define X_GLsop_GetLightfv 118
3356 void
3357 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3358 {
3359     __GLXcontext * const gc = __glXGetCurrentContext();
3360     Display * const dpy = gc->currentDpy;
3361     const GLuint cmdlen = 8;
3362     if (__builtin_expect(dpy != NULL, 1)) {
3363         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
3364         (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3365         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3366         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3367         UnlockDisplay(dpy); SyncHandle();
3368     }
3369     return;
3370 }
3371
3372 #define X_GLsop_GetLightiv 119
3373 void
3374 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3375 {
3376     __GLXcontext * const gc = __glXGetCurrentContext();
3377     Display * const dpy = gc->currentDpy;
3378     const GLuint cmdlen = 8;
3379     if (__builtin_expect(dpy != NULL, 1)) {
3380         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
3381         (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3382         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3383         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3384         UnlockDisplay(dpy); SyncHandle();
3385     }
3386     return;
3387 }
3388
3389 #define X_GLsop_GetMapdv 120
3390 void
3391 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3392 {
3393     __GLXcontext * const gc = __glXGetCurrentContext();
3394     Display * const dpy = gc->currentDpy;
3395     const GLuint cmdlen = 8;
3396     if (__builtin_expect(dpy != NULL, 1)) {
3397         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
3398         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3399         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3400         (void) __glXReadReply(dpy, 8, v, GL_FALSE);
3401         UnlockDisplay(dpy); SyncHandle();
3402     }
3403     return;
3404 }
3405
3406 #define X_GLsop_GetMapfv 121
3407 void
3408 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3409 {
3410     __GLXcontext * const gc = __glXGetCurrentContext();
3411     Display * const dpy = gc->currentDpy;
3412     const GLuint cmdlen = 8;
3413     if (__builtin_expect(dpy != NULL, 1)) {
3414         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
3415         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3416         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3417         (void) __glXReadReply(dpy, 4, v, GL_FALSE);
3418         UnlockDisplay(dpy); SyncHandle();
3419     }
3420     return;
3421 }
3422
3423 #define X_GLsop_GetMapiv 122
3424 void
3425 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
3426 {
3427     __GLXcontext * const gc = __glXGetCurrentContext();
3428     Display * const dpy = gc->currentDpy;
3429     const GLuint cmdlen = 8;
3430     if (__builtin_expect(dpy != NULL, 1)) {
3431         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
3432         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3433         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3434         (void) __glXReadReply(dpy, 4, v, GL_FALSE);
3435         UnlockDisplay(dpy); SyncHandle();
3436     }
3437     return;
3438 }
3439
3440 #define X_GLsop_GetMaterialfv 123
3441 void
3442 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
3443 {
3444     __GLXcontext * const gc = __glXGetCurrentContext();
3445     Display * const dpy = gc->currentDpy;
3446     const GLuint cmdlen = 8;
3447     if (__builtin_expect(dpy != NULL, 1)) {
3448         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
3449         (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3450         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3451         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3452         UnlockDisplay(dpy); SyncHandle();
3453     }
3454     return;
3455 }
3456
3457 #define X_GLsop_GetMaterialiv 124
3458 void
3459 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
3460 {
3461     __GLXcontext * const gc = __glXGetCurrentContext();
3462     Display * const dpy = gc->currentDpy;
3463     const GLuint cmdlen = 8;
3464     if (__builtin_expect(dpy != NULL, 1)) {
3465         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
3466         (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3467         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3468         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3469         UnlockDisplay(dpy); SyncHandle();
3470     }
3471     return;
3472 }
3473
3474 #define X_GLsop_GetPixelMapfv 125
3475 void
3476 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
3477 {
3478     __GLXcontext * const gc = __glXGetCurrentContext();
3479     Display * const dpy = gc->currentDpy;
3480     const GLuint cmdlen = 4;
3481     if (__builtin_expect(dpy != NULL, 1)) {
3482         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
3483         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3484         (void) __glXReadReply(dpy, 4, values, GL_FALSE);
3485         UnlockDisplay(dpy); SyncHandle();
3486     }
3487     return;
3488 }
3489
3490 #define X_GLsop_GetPixelMapuiv 126
3491 void
3492 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
3493 {
3494     __GLXcontext * const gc = __glXGetCurrentContext();
3495     Display * const dpy = gc->currentDpy;
3496     const GLuint cmdlen = 4;
3497     if (__builtin_expect(dpy != NULL, 1)) {
3498         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
3499         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3500         (void) __glXReadReply(dpy, 4, values, GL_FALSE);
3501         UnlockDisplay(dpy); SyncHandle();
3502     }
3503     return;
3504 }
3505
3506 #define X_GLsop_GetPixelMapusv 127
3507 void
3508 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
3509 {
3510     __GLXcontext * const gc = __glXGetCurrentContext();
3511     Display * const dpy = gc->currentDpy;
3512     const GLuint cmdlen = 4;
3513     if (__builtin_expect(dpy != NULL, 1)) {
3514         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
3515         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3516         (void) __glXReadReply(dpy, 2, values, GL_FALSE);
3517         UnlockDisplay(dpy); SyncHandle();
3518     }
3519     return;
3520 }
3521
3522 #define X_GLsop_GetPolygonStipple 128
3523 void
3524 __indirect_glGetPolygonStipple(GLubyte * mask)
3525 {
3526     __GLXcontext * const gc = __glXGetCurrentContext();
3527     const __GLXattribute * const state = gc->client_state_private;
3528     Display * const dpy = gc->currentDpy;
3529     const GLuint cmdlen = 4;
3530     if (__builtin_expect(dpy != NULL, 1)) {
3531         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
3532         *(int32_t *)(pc + 0) = 0;
3533         __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, GL_FALSE);
3534         UnlockDisplay(dpy); SyncHandle();
3535     }
3536     return;
3537 }
3538
3539 #define X_GLsop_GetTexEnvfv 130
3540 void
3541 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
3542 {
3543     __GLXcontext * const gc = __glXGetCurrentContext();
3544     Display * const dpy = gc->currentDpy;
3545     const GLuint cmdlen = 8;
3546     if (__builtin_expect(dpy != NULL, 1)) {
3547         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
3548         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3549         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3550         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3551         UnlockDisplay(dpy); SyncHandle();
3552     }
3553     return;
3554 }
3555
3556 #define X_GLsop_GetTexEnviv 131
3557 void
3558 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
3559 {
3560     __GLXcontext * const gc = __glXGetCurrentContext();
3561     Display * const dpy = gc->currentDpy;
3562     const GLuint cmdlen = 8;
3563     if (__builtin_expect(dpy != NULL, 1)) {
3564         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
3565         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3566         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3567         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3568         UnlockDisplay(dpy); SyncHandle();
3569     }
3570     return;
3571 }
3572
3573 #define X_GLsop_GetTexGendv 132
3574 void
3575 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
3576 {
3577     __GLXcontext * const gc = __glXGetCurrentContext();
3578     Display * const dpy = gc->currentDpy;
3579     const GLuint cmdlen = 8;
3580     if (__builtin_expect(dpy != NULL, 1)) {
3581         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
3582         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3583         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3584         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
3585         UnlockDisplay(dpy); SyncHandle();
3586     }
3587     return;
3588 }
3589
3590 #define X_GLsop_GetTexGenfv 133
3591 void
3592 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
3593 {
3594     __GLXcontext * const gc = __glXGetCurrentContext();
3595     Display * const dpy = gc->currentDpy;
3596     const GLuint cmdlen = 8;
3597     if (__builtin_expect(dpy != NULL, 1)) {
3598         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
3599         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3600         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3601         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3602         UnlockDisplay(dpy); SyncHandle();
3603     }
3604     return;
3605 }
3606
3607 #define X_GLsop_GetTexGeniv 134
3608 void
3609 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
3610 {
3611     __GLXcontext * const gc = __glXGetCurrentContext();
3612     Display * const dpy = gc->currentDpy;
3613     const GLuint cmdlen = 8;
3614     if (__builtin_expect(dpy != NULL, 1)) {
3615         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
3616         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3617         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3618         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3619         UnlockDisplay(dpy); SyncHandle();
3620     }
3621     return;
3622 }
3623
3624 #define X_GLsop_GetTexImage 135
3625 void
3626 __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
3627 {
3628     __GLXcontext * const gc = __glXGetCurrentContext();
3629     const __GLXattribute * const state = gc->client_state_private;
3630     Display * const dpy = gc->currentDpy;
3631     const GLuint cmdlen = 20;
3632     if (__builtin_expect(dpy != NULL, 1)) {
3633         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
3634         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3635         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3636         (void) memcpy((void *)(pc + 8), (void *)(&format), 4);
3637         (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
3638         *(int32_t *)(pc + 16) = 0;
3639         * (int8_t *)(pc + 16) = state->storePack.swapEndian;
3640         __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE);
3641         UnlockDisplay(dpy); SyncHandle();
3642     }
3643     return;
3644 }
3645
3646 #define X_GLsop_GetTexParameterfv 136
3647 void
3648 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
3649 {
3650     __GLXcontext * const gc = __glXGetCurrentContext();
3651     Display * const dpy = gc->currentDpy;
3652     const GLuint cmdlen = 8;
3653     if (__builtin_expect(dpy != NULL, 1)) {
3654         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
3655         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3656         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3657         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3658         UnlockDisplay(dpy); SyncHandle();
3659     }
3660     return;
3661 }
3662
3663 #define X_GLsop_GetTexParameteriv 137
3664 void
3665 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
3666 {
3667     __GLXcontext * const gc = __glXGetCurrentContext();
3668     Display * const dpy = gc->currentDpy;
3669     const GLuint cmdlen = 8;
3670     if (__builtin_expect(dpy != NULL, 1)) {
3671         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
3672         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3673         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3674         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3675         UnlockDisplay(dpy); SyncHandle();
3676     }
3677     return;
3678 }
3679
3680 #define X_GLsop_GetTexLevelParameterfv 138
3681 void
3682 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
3683 {
3684     __GLXcontext * const gc = __glXGetCurrentContext();
3685     Display * const dpy = gc->currentDpy;
3686     const GLuint cmdlen = 12;
3687     if (__builtin_expect(dpy != NULL, 1)) {
3688         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
3689         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3690         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3691         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3692         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3693         UnlockDisplay(dpy); SyncHandle();
3694     }
3695     return;
3696 }
3697
3698 #define X_GLsop_GetTexLevelParameteriv 139
3699 void
3700 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
3701 {
3702     __GLXcontext * const gc = __glXGetCurrentContext();
3703     Display * const dpy = gc->currentDpy;
3704     const GLuint cmdlen = 12;
3705     if (__builtin_expect(dpy != NULL, 1)) {
3706         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
3707         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3708         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3709         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3710         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3711         UnlockDisplay(dpy); SyncHandle();
3712     }
3713     return;
3714 }
3715
3716 #define X_GLsop_IsList 141
3717 GLboolean
3718 __indirect_glIsList(GLuint list)
3719 {
3720     __GLXcontext * const gc = __glXGetCurrentContext();
3721     Display * const dpy = gc->currentDpy;
3722     GLboolean retval = (GLboolean) 0;
3723     const GLuint cmdlen = 4;
3724     if (__builtin_expect(dpy != NULL, 1)) {
3725         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
3726         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
3727         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
3728         UnlockDisplay(dpy); SyncHandle();
3729     }
3730     return retval;
3731 }
3732
3733 #define X_GLrop_DepthRange 174
3734 void
3735 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
3736 {
3737     __GLXcontext * const gc = __glXGetCurrentContext();
3738     const GLuint cmdlen = 20;
3739     emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
3740     (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
3741     (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
3742     gc->pc += cmdlen;
3743     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3744 }
3745
3746 #define X_GLrop_Frustum 175
3747 void
3748 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3749 {
3750     __GLXcontext * const gc = __glXGetCurrentContext();
3751     const GLuint cmdlen = 52;
3752     emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
3753     (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3754     (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3755     (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3756     (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3757     (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3758     (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3759     gc->pc += cmdlen;
3760     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3761 }
3762
3763 #define X_GLrop_LoadIdentity 176
3764 void
3765 __indirect_glLoadIdentity(void)
3766 {
3767     __GLXcontext * const gc = __glXGetCurrentContext();
3768     const GLuint cmdlen = 4;
3769     emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
3770     gc->pc += cmdlen;
3771     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3772 }
3773
3774 #define X_GLrop_LoadMatrixf 177
3775 void
3776 __indirect_glLoadMatrixf(const GLfloat * m)
3777 {
3778     __GLXcontext * const gc = __glXGetCurrentContext();
3779     const GLuint cmdlen = 68;
3780     emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
3781     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3782     gc->pc += cmdlen;
3783     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3784 }
3785
3786 #define X_GLrop_LoadMatrixd 178
3787 void
3788 __indirect_glLoadMatrixd(const GLdouble * m)
3789 {
3790     __GLXcontext * const gc = __glXGetCurrentContext();
3791     const GLuint cmdlen = 132;
3792     emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
3793     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3794     gc->pc += cmdlen;
3795     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3796 }
3797
3798 #define X_GLrop_MatrixMode 179
3799 void
3800 __indirect_glMatrixMode(GLenum mode)
3801 {
3802     __GLXcontext * const gc = __glXGetCurrentContext();
3803     const GLuint cmdlen = 8;
3804     emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
3805     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3806     gc->pc += cmdlen;
3807     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3808 }
3809
3810 #define X_GLrop_MultMatrixf 180
3811 void
3812 __indirect_glMultMatrixf(const GLfloat * m)
3813 {
3814     __GLXcontext * const gc = __glXGetCurrentContext();
3815     const GLuint cmdlen = 68;
3816     emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
3817     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3818     gc->pc += cmdlen;
3819     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3820 }
3821
3822 #define X_GLrop_MultMatrixd 181
3823 void
3824 __indirect_glMultMatrixd(const GLdouble * m)
3825 {
3826     __GLXcontext * const gc = __glXGetCurrentContext();
3827     const GLuint cmdlen = 132;
3828     emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
3829     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3830     gc->pc += cmdlen;
3831     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3832 }
3833
3834 #define X_GLrop_Ortho 182
3835 void
3836 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3837 {
3838     __GLXcontext * const gc = __glXGetCurrentContext();
3839     const GLuint cmdlen = 52;
3840     emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
3841     (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3842     (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3843     (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3844     (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3845     (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3846     (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3847     gc->pc += cmdlen;
3848     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3849 }
3850
3851 #define X_GLrop_PopMatrix 183
3852 void
3853 __indirect_glPopMatrix(void)
3854 {
3855     __GLXcontext * const gc = __glXGetCurrentContext();
3856     const GLuint cmdlen = 4;
3857     emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
3858     gc->pc += cmdlen;
3859     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3860 }
3861
3862 #define X_GLrop_PushMatrix 184
3863 void
3864 __indirect_glPushMatrix(void)
3865 {
3866     __GLXcontext * const gc = __glXGetCurrentContext();
3867     const GLuint cmdlen = 4;
3868     emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
3869     gc->pc += cmdlen;
3870     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3871 }
3872
3873 #define X_GLrop_Rotated 185
3874 void
3875 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3876 {
3877     __GLXcontext * const gc = __glXGetCurrentContext();
3878     const GLuint cmdlen = 36;
3879     emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
3880     (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
3881     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
3882     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
3883     (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
3884     gc->pc += cmdlen;
3885     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3886 }
3887
3888 #define X_GLrop_Rotatef 186
3889 void
3890 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3891 {
3892     __GLXcontext * const gc = __glXGetCurrentContext();
3893     const GLuint cmdlen = 20;
3894     emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
3895     (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
3896     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
3897     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
3898     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
3899     gc->pc += cmdlen;
3900     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3901 }
3902
3903 #define X_GLrop_Scaled 187
3904 void
3905 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
3906 {
3907     __GLXcontext * const gc = __glXGetCurrentContext();
3908     const GLuint cmdlen = 28;
3909     emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
3910     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
3911     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
3912     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
3913     gc->pc += cmdlen;
3914     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3915 }
3916
3917 #define X_GLrop_Scalef 188
3918 void
3919 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
3920 {
3921     __GLXcontext * const gc = __glXGetCurrentContext();
3922     const GLuint cmdlen = 16;
3923     emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
3924     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3925     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3926     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
3927     gc->pc += cmdlen;
3928     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3929 }
3930
3931 #define X_GLrop_Translated 189
3932 void
3933 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
3934 {
3935     __GLXcontext * const gc = __glXGetCurrentContext();
3936     const GLuint cmdlen = 28;
3937     emit_header(gc->pc, X_GLrop_Translated, cmdlen);
3938     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
3939     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
3940     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
3941     gc->pc += cmdlen;
3942     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3943 }
3944
3945 #define X_GLrop_Translatef 190
3946 void
3947 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
3948 {
3949     __GLXcontext * const gc = __glXGetCurrentContext();
3950     const GLuint cmdlen = 16;
3951     emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
3952     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3953     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3954     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
3955     gc->pc += cmdlen;
3956     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3957 }
3958
3959 #define X_GLrop_Viewport 191
3960 void
3961 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
3962 {
3963     __GLXcontext * const gc = __glXGetCurrentContext();
3964     const GLuint cmdlen = 20;
3965     emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
3966     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3967     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3968     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3969     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3970     gc->pc += cmdlen;
3971     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3972 }
3973
3974 #define X_GLrop_BindTexture 4117
3975 void
3976 __indirect_glBindTexture(GLenum target, GLuint texture)
3977 {
3978     __GLXcontext * const gc = __glXGetCurrentContext();
3979     const GLuint cmdlen = 12;
3980     emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
3981     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3982     (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
3983     gc->pc += cmdlen;
3984     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3985 }
3986
3987 #define X_GLrop_Indexubv 194
3988 void
3989 __indirect_glIndexub(GLubyte c)
3990 {
3991     __GLXcontext * const gc = __glXGetCurrentContext();
3992     const GLuint cmdlen = 8;
3993     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
3994     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
3995     gc->pc += cmdlen;
3996     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3997 }
3998
3999 #define X_GLrop_Indexubv 194
4000 void
4001 __indirect_glIndexubv(const GLubyte * c)
4002 {
4003     __GLXcontext * const gc = __glXGetCurrentContext();
4004     const GLuint cmdlen = 8;
4005     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4006     (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
4007     gc->pc += cmdlen;
4008     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4009 }
4010
4011 #define X_GLrop_PolygonOffset 192
4012 void
4013 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
4014 {
4015     __GLXcontext * const gc = __glXGetCurrentContext();
4016     const GLuint cmdlen = 12;
4017     emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
4018     (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
4019     (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
4020     gc->pc += cmdlen;
4021     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4022 }
4023
4024 #define X_GLsop_AreTexturesResident 143
4025 GLboolean
4026 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
4027 {
4028     __GLXcontext * const gc = __glXGetCurrentContext();
4029     Display * const dpy = gc->currentDpy;
4030     GLboolean retval = (GLboolean) 0;
4031     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4032     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4033         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
4034         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4035         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4036         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
4037         UnlockDisplay(dpy); SyncHandle();
4038     }
4039     return retval;
4040 }
4041
4042 #define X_GLrop_CopyTexImage1D 4119
4043 void
4044 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
4045 {
4046     __GLXcontext * const gc = __glXGetCurrentContext();
4047     const GLuint cmdlen = 32;
4048     emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
4049     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4050     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4051     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4052     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4053     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4054     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4055     (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
4056     gc->pc += cmdlen;
4057     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4058 }
4059
4060 #define X_GLrop_CopyTexImage2D 4120
4061 void
4062 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
4063 {
4064     __GLXcontext * const gc = __glXGetCurrentContext();
4065     const GLuint cmdlen = 36;
4066     emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
4067     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4068     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4069     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4070     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4071     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4072     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4073     (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
4074     (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
4075     gc->pc += cmdlen;
4076     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4077 }
4078
4079 #define X_GLrop_CopyTexSubImage1D 4121
4080 void
4081 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
4082 {
4083     __GLXcontext * const gc = __glXGetCurrentContext();
4084     const GLuint cmdlen = 28;
4085     emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
4086     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4087     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4088     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4089     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4090     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4091     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4092     gc->pc += cmdlen;
4093     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4094 }
4095
4096 #define X_GLrop_CopyTexSubImage2D 4122
4097 void
4098 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4099 {
4100     __GLXcontext * const gc = __glXGetCurrentContext();
4101     const GLuint cmdlen = 36;
4102     emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
4103     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4104     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4105     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4106     (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4107     (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
4108     (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
4109     (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
4110     (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
4111     gc->pc += cmdlen;
4112     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4113 }
4114
4115 #define X_GLsop_DeleteTextures 144
4116 void
4117 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
4118 {
4119     __GLXcontext * const gc = __glXGetCurrentContext();
4120     Display * const dpy = gc->currentDpy;
4121     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4122     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4123         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen);
4124         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4125         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4126         UnlockDisplay(dpy); SyncHandle();
4127     }
4128     return;
4129 }
4130
4131 #define X_GLsop_GenTextures 145
4132 void
4133 __indirect_glGenTextures(GLsizei n, GLuint * textures)
4134 {
4135     __GLXcontext * const gc = __glXGetCurrentContext();
4136     Display * const dpy = gc->currentDpy;
4137     const GLuint cmdlen = 4;
4138     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4139         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
4140         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4141         (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
4142         UnlockDisplay(dpy); SyncHandle();
4143     }
4144     return;
4145 }
4146
4147 #define X_GLsop_IsTexture 146
4148 GLboolean
4149 __indirect_glIsTexture(GLuint texture)
4150 {
4151     __GLXcontext * const gc = __glXGetCurrentContext();
4152     Display * const dpy = gc->currentDpy;
4153     GLboolean retval = (GLboolean) 0;
4154     const GLuint cmdlen = 4;
4155     if (__builtin_expect(dpy != NULL, 1)) {
4156         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
4157         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
4158         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
4159         UnlockDisplay(dpy); SyncHandle();
4160     }
4161     return retval;
4162 }
4163
4164 #define X_GLrop_PrioritizeTextures 4118
4165 void
4166 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
4167 {
4168     __GLXcontext * const gc = __glXGetCurrentContext();
4169     const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
4170     if (__builtin_expect(n >= 0, 1)) {
4171         emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
4172         (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
4173         (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
4174         (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
4175         gc->pc += cmdlen;
4176         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4177     }
4178 }
4179
4180 static void
4181 __glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels )
4182 {
4183     __GLXcontext * const gc = __glXGetCurrentContext();
4184     const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
4185     const GLuint cmdlen = 60 + __GLX_PAD(compsize);
4186     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4187         if (cmdlen <= gc->maxSmallRenderCommandSize) {
4188             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4189                 (void) __glXFlushRenderBuffer(gc, gc->pc);
4190             }
4191             emit_header(gc->pc, opcode, cmdlen);
4192             (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4193             (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
4194             (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4);
4195             (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4);
4196             (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4);
4197             (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4);
4198             (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
4199             (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
4200             (void) memcpy((void *)(gc->pc + 56), (void *)((pixels == NULL) ? one : zero), 4);
4201             if (compsize > 0) {
4202                 (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4);
4203             }
4204             else {
4205                 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
4206             }
4207             gc->pc += cmdlen;
4208             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4209         }
4210         else {
4211             const GLint op = opcode;
4212             const GLuint cmdlenLarge = cmdlen + 4;
4213             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4214             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4215             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4216             (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4217             (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
4218             (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4);
4219             (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4);
4220             (void) memcpy((void *)(pc + 44), (void *)(&width), 4);
4221             (void) memcpy((void *)(pc + 48), (void *)(&height), 4);
4222             (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
4223             (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
4224             (void) memcpy((void *)(pc + 60), zero, 4);
4225             __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8);
4226         }
4227     }
4228 }
4229
4230 #define X_GLrop_TexSubImage1D 4099
4231 void
4232 __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
4233 {
4234     __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels );
4235 }
4236
4237 #define X_GLrop_TexSubImage2D 4100
4238 void
4239 __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
4240 {
4241     __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels );
4242 }
4243
4244 #define X_GLrop_BlendColor 4096
4245 void
4246 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
4247 {
4248     __GLXcontext * const gc = __glXGetCurrentContext();
4249     const GLuint cmdlen = 20;
4250     emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
4251     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
4252     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
4253     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
4254     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
4255     gc->pc += cmdlen;
4256     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4257 }
4258
4259 #define X_GLrop_BlendEquation 4097
4260 void
4261 __indirect_glBlendEquation(GLenum mode)
4262 {
4263     __GLXcontext * const gc = __glXGetCurrentContext();
4264     const GLuint cmdlen = 8;
4265     emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
4266     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
4267     gc->pc += cmdlen;
4268     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4269 }
4270
4271 #define X_GLrop_ColorTable 2053
4272 void
4273 __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
4274 {
4275     __GLXcontext * const gc = __glXGetCurrentContext();
4276     const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0;
4277     const GLuint cmdlen = 44 + __GLX_PAD(compsize);
4278     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4279         if (cmdlen <= gc->maxSmallRenderCommandSize) {
4280             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4281                 (void) __glXFlushRenderBuffer(gc, gc->pc);
4282             }
4283             emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
4284             (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4285             (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
4286             (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4287             (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
4288             (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
4289             if (compsize > 0) {
4290                 (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4);
4291             }
4292             else {
4293                 (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
4294             }
4295             gc->pc += cmdlen;
4296             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4297         }
4298         else {
4299             const GLint op = X_GLrop_ColorTable;
4300             const GLuint cmdlenLarge = cmdlen + 4;
4301             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4302             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4303             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4304             (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4305             (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
4306             (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
4307             (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
4308             (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
4309             __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8);
4310         }
4311     }
4312 }
4313
4314 #define X_GLrop_ColorTableParameterfv 2054
4315 void
4316 __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4317 {
4318     __GLXcontext * const gc = __glXGetCurrentContext();
4319     const GLuint compsize = __glColorTableParameterfv_size(pname);
4320     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4321     emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
4322     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4323     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4324     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4325     gc->pc += cmdlen;
4326     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4327 }
4328
4329 #define X_GLrop_ColorTableParameteriv 2055
4330 void
4331 __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
4332 {
4333     __GLXcontext * const gc = __glXGetCurrentContext();
4334     const GLuint compsize = __glColorTableParameteriv_size(pname);
4335     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4336     emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
4337     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4338     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4339     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4340     gc->pc += cmdlen;
4341     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4342 }
4343
4344 #define X_GLrop_CopyColorTable 2056
4345 void
4346 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4347 {
4348     __GLXcontext * const gc = __glXGetCurrentContext();
4349     const GLuint cmdlen = 24;
4350     emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
4351     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4352     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4353     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4354     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4355     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4356     gc->pc += cmdlen;
4357     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4358 }
4359
4360 #define X_GLsop_GetColorTable 147
4361 void
4362 __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)
4363 {
4364     __GLXcontext * const gc = __glXGetCurrentContext();
4365     const __GLXattribute * const state = gc->client_state_private;
4366     Display * const dpy = gc->currentDpy;
4367     const GLuint cmdlen = 16;
4368     if (__builtin_expect(dpy != NULL, 1)) {
4369         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
4370         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4371         (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4372         (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4373         *(int32_t *)(pc + 12) = 0;
4374         * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4375         __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
4376         UnlockDisplay(dpy); SyncHandle();
4377     }
4378     return;
4379 }
4380
4381 #define X_GLsop_GetColorTableParameterfv 148
4382 void
4383 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
4384 {
4385     __GLXcontext * const gc = __glXGetCurrentContext();
4386     Display * const dpy = gc->currentDpy;
4387     const GLuint cmdlen = 8;
4388     if (__builtin_expect(dpy != NULL, 1)) {
4389         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
4390         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4391         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4392         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4393         UnlockDisplay(dpy); SyncHandle();
4394     }
4395     return;
4396 }
4397
4398 #define X_GLsop_GetColorTableParameteriv 149
4399 void
4400 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
4401 {
4402     __GLXcontext * const gc = __glXGetCurrentContext();
4403     Display * const dpy = gc->currentDpy;
4404     const GLuint cmdlen = 8;
4405     if (__builtin_expect(dpy != NULL, 1)) {
4406         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
4407         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4408         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4409         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4410         UnlockDisplay(dpy); SyncHandle();
4411     }
4412     return;
4413 }
4414
4415 #define X_GLrop_ColorSubTable 195
4416 void
4417 __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
4418 {
4419     __GLXcontext * const gc = __glXGetCurrentContext();
4420     const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
4421     const GLuint cmdlen = 44 + __GLX_PAD(compsize);
4422     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4423         if (cmdlen <= gc->maxSmallRenderCommandSize) {
4424             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4425                 (void) __glXFlushRenderBuffer(gc, gc->pc);
4426             }
4427             emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
4428             (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4429             (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4);
4430             (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4);
4431             (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
4432             (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
4433             if (compsize > 0) {
4434                 (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4);
4435             }
4436             else {
4437                 (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
4438             }
4439             gc->pc += cmdlen;
4440             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4441         }
4442         else {
4443             const GLint op = X_GLrop_ColorSubTable;
4444             const GLuint cmdlenLarge = cmdlen + 4;
4445             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4446             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4447             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4448             (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4449             (void) memcpy((void *)(pc + 32), (void *)(&start), 4);
4450             (void) memcpy((void *)(pc + 36), (void *)(&count), 4);
4451             (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
4452             (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
4453             __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8);
4454         }
4455     }
4456 }
4457
4458 #define X_GLrop_CopyColorSubTable 196
4459 void
4460 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
4461 {
4462     __GLXcontext * const gc = __glXGetCurrentContext();
4463     const GLuint cmdlen = 24;
4464     emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
4465     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4466     (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
4467     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4468     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4469     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4470     gc->pc += cmdlen;
4471     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4472 }
4473
4474 static void
4475 __glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image )
4476 {
4477     __GLXcontext * const gc = __glXGetCurrentContext();
4478     const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
4479     const GLuint cmdlen = 48 + __GLX_PAD(compsize);
4480     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4481         if (cmdlen <= gc->maxSmallRenderCommandSize) {
4482             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4483                 (void) __glXFlushRenderBuffer(gc, gc->pc);
4484             }
4485             emit_header(gc->pc, opcode, cmdlen);
4486             (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4487             (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
4488             (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4489             (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
4490             (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4);
4491             (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4);
4492             if (compsize > 0) {
4493                 (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4);
4494             }
4495             else {
4496                 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
4497             }
4498             gc->pc += cmdlen;
4499             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4500         }
4501         else {
4502             const GLint op = opcode;
4503             const GLuint cmdlenLarge = cmdlen + 4;
4504             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4505             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4506             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4507             (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4508             (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
4509             (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
4510             (void) memcpy((void *)(pc + 40), (void *)(&height), 4);
4511             (void) memcpy((void *)(pc + 44), (void *)(&format), 4);
4512             (void) memcpy((void *)(pc + 48), (void *)(&type), 4);
4513             __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8);
4514         }
4515     }
4516 }
4517
4518 #define X_GLrop_ConvolutionFilter1D 4101
4519 void
4520 __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
4521 {
4522     __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image );
4523 }
4524
4525 #define X_GLrop_ConvolutionFilter2D 4102
4526 void
4527 __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
4528 {
4529     __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image );
4530 }
4531
4532 #define X_GLrop_ConvolutionParameterf 4103
4533 void
4534 __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
4535 {
4536     __GLXcontext * const gc = __glXGetCurrentContext();
4537     const GLuint cmdlen = 16;
4538     emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
4539     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4540     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4541     (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4542     gc->pc += cmdlen;
4543     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4544 }
4545
4546 #define X_GLrop_ConvolutionParameterfv 4104
4547 void
4548 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4549 {
4550     __GLXcontext * const gc = __glXGetCurrentContext();
4551     const GLuint compsize = __glConvolutionParameterfv_size(pname);
4552     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4553     emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
4554     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4555     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4556     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4557     gc->pc += cmdlen;
4558     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4559 }
4560
4561 #define X_GLrop_ConvolutionParameteri 4105
4562 void
4563 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
4564 {
4565     __GLXcontext * const gc = __glXGetCurrentContext();
4566     const GLuint cmdlen = 16;
4567     emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
4568     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4569     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4570     (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4571     gc->pc += cmdlen;
4572     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4573 }
4574
4575 #define X_GLrop_ConvolutionParameteriv 4106
4576 void
4577 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
4578 {
4579     __GLXcontext * const gc = __glXGetCurrentContext();
4580     const GLuint compsize = __glConvolutionParameteriv_size(pname);
4581     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4582     emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
4583     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4584     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4585     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4586     gc->pc += cmdlen;
4587     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4588 }
4589
4590 #define X_GLrop_CopyConvolutionFilter1D 4107
4591 void
4592 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4593 {
4594     __GLXcontext * const gc = __glXGetCurrentContext();
4595     const GLuint cmdlen = 24;
4596     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
4597     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4598     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4599     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4600     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4601     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4602     gc->pc += cmdlen;
4603     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4604 }
4605
4606 #define X_GLrop_CopyConvolutionFilter2D 4108
4607 void
4608 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
4609 {
4610     __GLXcontext * const gc = __glXGetCurrentContext();
4611     const GLuint cmdlen = 28;
4612     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
4613     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4614     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4615     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4616     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4617     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4618     (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
4619     gc->pc += cmdlen;
4620     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4621 }
4622
4623 #define X_GLsop_GetConvolutionFilter 150
4624 void
4625 __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)
4626 {
4627     __GLXcontext * const gc = __glXGetCurrentContext();
4628     const __GLXattribute * const state = gc->client_state_private;
4629     Display * const dpy = gc->currentDpy;
4630     const GLuint cmdlen = 16;
4631     if (__builtin_expect(dpy != NULL, 1)) {
4632         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
4633         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4634         (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4635         (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4636         *(int32_t *)(pc + 12) = 0;
4637         * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4638         __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
4639         UnlockDisplay(dpy); SyncHandle();
4640     }
4641     return;
4642 }
4643
4644 #define X_GLsop_GetConvolutionParameterfv 151
4645 void
4646 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
4647 {
4648     __GLXcontext * const gc = __glXGetCurrentContext();
4649     Display * const dpy = gc->currentDpy;
4650     const GLuint cmdlen = 8;
4651     if (__builtin_expect(dpy != NULL, 1)) {
4652         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
4653         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4654         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4655         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4656         UnlockDisplay(dpy); SyncHandle();
4657     }
4658     return;
4659 }
4660
4661 #define X_GLsop_GetConvolutionParameteriv 152
4662 void
4663 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
4664 {
4665     __GLXcontext * const gc = __glXGetCurrentContext();
4666     Display * const dpy = gc->currentDpy;
4667     const GLuint cmdlen = 8;
4668     if (__builtin_expect(dpy != NULL, 1)) {
4669         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
4670         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4671         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4672         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4673         UnlockDisplay(dpy); SyncHandle();
4674     }
4675     return;
4676 }
4677
4678 #define X_GLsop_GetHistogram 154
4679 void
4680 __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
4681 {
4682     __GLXcontext * const gc = __glXGetCurrentContext();
4683     const __GLXattribute * const state = gc->client_state_private;
4684     Display * const dpy = gc->currentDpy;
4685     const GLuint cmdlen = 16;
4686     if (__builtin_expect(dpy != NULL, 1)) {
4687         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
4688         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4689         (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4690         (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4691         *(int32_t *)(pc + 12) = 0;
4692         * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4693         * (int8_t *)(pc + 13) = reset;
4694         __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
4695         UnlockDisplay(dpy); SyncHandle();
4696     }
4697     return;
4698 }
4699
4700 #define X_GLsop_GetHistogramParameterfv 155
4701 void
4702 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
4703 {
4704     __GLXcontext * const gc = __glXGetCurrentContext();
4705     Display * const dpy = gc->currentDpy;
4706     const GLuint cmdlen = 8;
4707     if (__builtin_expect(dpy != NULL, 1)) {
4708         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
4709         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4710         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4711         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4712         UnlockDisplay(dpy); SyncHandle();
4713     }
4714     return;
4715 }
4716
4717 #define X_GLsop_GetHistogramParameteriv 156
4718 void
4719 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
4720 {
4721     __GLXcontext * const gc = __glXGetCurrentContext();
4722     Display * const dpy = gc->currentDpy;
4723     const GLuint cmdlen = 8;
4724     if (__builtin_expect(dpy != NULL, 1)) {
4725         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
4726         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4727         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4728         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4729         UnlockDisplay(dpy); SyncHandle();
4730     }
4731     return;
4732 }
4733
4734 #define X_GLsop_GetMinmax 157
4735 void
4736 __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
4737 {
4738     __GLXcontext * const gc = __glXGetCurrentContext();
4739     const __GLXattribute * const state = gc->client_state_private;
4740     Display * const dpy = gc->currentDpy;
4741     const GLuint cmdlen = 16;
4742     if (__builtin_expect(dpy != NULL, 1)) {
4743         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
4744         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4745         (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4746         (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4747         *(int32_t *)(pc + 12) = 0;
4748         * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4749         * (int8_t *)(pc + 13) = reset;
4750         __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE);
4751         UnlockDisplay(dpy); SyncHandle();
4752     }
4753     return;
4754 }
4755
4756 #define X_GLsop_GetMinmaxParameterfv 158
4757 void
4758 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
4759 {
4760     __GLXcontext * const gc = __glXGetCurrentContext();
4761     Display * const dpy = gc->currentDpy;
4762     const GLuint cmdlen = 8;
4763     if (__builtin_expect(dpy != NULL, 1)) {
4764         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
4765         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4766         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4767         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4768         UnlockDisplay(dpy); SyncHandle();
4769     }
4770     return;
4771 }
4772
4773 #define X_GLsop_GetMinmaxParameteriv 159
4774 void
4775 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
4776 {
4777     __GLXcontext * const gc = __glXGetCurrentContext();
4778     Display * const dpy = gc->currentDpy;
4779     const GLuint cmdlen = 8;
4780     if (__builtin_expect(dpy != NULL, 1)) {
4781         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
4782         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4783         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4784         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4785         UnlockDisplay(dpy); SyncHandle();
4786     }
4787     return;
4788 }
4789
4790 #define X_GLrop_Histogram 4110
4791 void
4792 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
4793 {
4794     __GLXcontext * const gc = __glXGetCurrentContext();
4795     const GLuint cmdlen = 20;
4796     emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
4797     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4798     (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
4799     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4800     (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
4801     gc->pc += cmdlen;
4802     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4803 }
4804
4805 #define X_GLrop_Minmax 4111
4806 void
4807 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
4808 {
4809     __GLXcontext * const gc = __glXGetCurrentContext();
4810     const GLuint cmdlen = 16;
4811     emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
4812     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4813     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4814     (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
4815     gc->pc += cmdlen;
4816     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4817 }
4818
4819 #define X_GLrop_ResetHistogram 4112
4820 void
4821 __indirect_glResetHistogram(GLenum target)
4822 {
4823     __GLXcontext * const gc = __glXGetCurrentContext();
4824     const GLuint cmdlen = 8;
4825     emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
4826     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4827     gc->pc += cmdlen;
4828     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4829 }
4830
4831 #define X_GLrop_ResetMinmax 4113
4832 void
4833 __indirect_glResetMinmax(GLenum target)
4834 {
4835     __GLXcontext * const gc = __glXGetCurrentContext();
4836     const GLuint cmdlen = 8;
4837     emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
4838     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4839     gc->pc += cmdlen;
4840     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4841 }
4842
4843 static void
4844 __glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
4845 {
4846     __GLXcontext * const gc = __glXGetCurrentContext();
4847     const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
4848     const GLuint cmdlen = 84 + __GLX_PAD(compsize);
4849     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4850         if (cmdlen <= gc->maxSmallRenderCommandSize) {
4851             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4852                 (void) __glXFlushRenderBuffer(gc, gc->pc);
4853             }
4854             emit_header(gc->pc, opcode, cmdlen);
4855             (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
4856             (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
4857             (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4);
4858             (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4);
4859             (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4);
4860             (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4);
4861             (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4);
4862             (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4);
4863             (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4);
4864             (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4);
4865             (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4);
4866             if (compsize > 0) {
4867                 (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4);
4868             }
4869             else {
4870                 (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
4871             }
4872             gc->pc += cmdlen;
4873             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4874         }
4875         else {
4876             const GLint op = opcode;
4877             const GLuint cmdlenLarge = cmdlen + 4;
4878             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4879             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4880             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4881             (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
4882             (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
4883             (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4);
4884             (void) memcpy((void *)(pc + 56), (void *)(&width), 4);
4885             (void) memcpy((void *)(pc + 60), (void *)(&height), 4);
4886             (void) memcpy((void *)(pc + 64), (void *)(&depth), 4);
4887             (void) memcpy((void *)(pc + 68), (void *)(&extent), 4);
4888             (void) memcpy((void *)(pc + 72), (void *)(&border), 4);
4889             (void) memcpy((void *)(pc + 76), (void *)(&format), 4);
4890             (void) memcpy((void *)(pc + 80), (void *)(&type), 4);
4891             (void) memcpy((void *)(pc + 84), zero, 4);
4892             __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8);
4893         }
4894     }
4895 }
4896
4897 #define X_GLrop_TexImage3D 4114
4898 void
4899 __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
4900 {
4901     __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels );
4902 }
4903
4904 static void
4905 __glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels )
4906 {
4907     __GLXcontext * const gc = __glXGetCurrentContext();
4908     const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
4909     const GLuint cmdlen = 92 + __GLX_PAD(compsize);
4910     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4911         if (cmdlen <= gc->maxSmallRenderCommandSize) {
4912             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4913                 (void) __glXFlushRenderBuffer(gc, gc->pc);
4914             }
4915             emit_header(gc->pc, opcode, cmdlen);
4916             (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
4917             (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
4918             (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4);
4919             (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4);
4920             (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4);
4921             (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4);
4922             (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4);
4923             (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4);
4924             (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4);
4925             (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4);
4926             (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4);
4927             (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4);
4928             (void) memcpy((void *)(gc->pc + 88), (void *)((pixels == NULL) ? one : zero), 4);
4929             if (compsize > 0) {
4930                 (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4);
4931             }
4932             else {
4933                 (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
4934             }
4935             gc->pc += cmdlen;
4936             if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4937         }
4938         else {
4939             const GLint op = opcode;
4940             const GLuint cmdlenLarge = cmdlen + 4;
4941             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4942             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4943             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4944             (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
4945             (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
4946             (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4);
4947             (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4);
4948             (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4);
4949             (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4);
4950             (void) memcpy((void *)(pc + 68), (void *)(&width), 4);
4951             (void) memcpy((void *)(pc + 72), (void *)(&height), 4);
4952             (void) memcpy((void *)(pc + 76), (void *)(&depth), 4);
4953             (void) memcpy((void *)(pc + 80), (void *)(&extent), 4);
4954             (void) memcpy((void *)(pc + 84), (void *)(&format), 4);
4955             (void) memcpy((void *)(pc + 88), (void *)(&type), 4);
4956             (void) memcpy((void *)(pc + 92), zero, 4);
4957             __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8);
4958         }
4959     }
4960 }
4961
4962 #define X_GLrop_TexSubImage3D 4115
4963 void
4964 __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
4965 {
4966     __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels );
4967 }
4968
4969 #define X_GLrop_CopyTexSubImage3D 4123
4970 void
4971 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4972 {
4973     __GLXcontext * const gc = __glXGetCurrentContext();
4974     const GLuint cmdlen = 40;
4975     emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
4976     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4977     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4978     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4979     (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4980     (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
4981     (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
4982     (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
4983     (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4984     (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
4985     gc->pc += cmdlen;
4986     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4987 }
4988
4989 #define X_GLrop_ActiveTextureARB 197
4990 void
4991 __indirect_glActiveTextureARB(GLenum texture)
4992 {
4993     __GLXcontext * const gc = __glXGetCurrentContext();
4994     const GLuint cmdlen = 8;
4995     emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
4996     (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
4997     gc->pc += cmdlen;
4998     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4999 }
5000
5001 #define X_GLrop_MultiTexCoord1dvARB 198
5002 void
5003 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
5004 {
5005     __GLXcontext * const gc = __glXGetCurrentContext();
5006     const GLuint cmdlen = 16;
5007     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
5008     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5009     (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
5010     gc->pc += cmdlen;
5011     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5012 }
5013
5014 #define X_GLrop_MultiTexCoord1dvARB 198
5015 void
5016 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
5017 {
5018     __GLXcontext * const gc = __glXGetCurrentContext();
5019     const GLuint cmdlen = 16;
5020     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
5021     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
5022     (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
5023     gc->pc += cmdlen;
5024     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5025 }
5026
5027 #define X_GLrop_MultiTexCoord1fvARB 199
5028 void
5029 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
5030 {
5031     __GLXcontext * const gc = __glXGetCurrentContext();
5032     const GLuint cmdlen = 12;
5033     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
5034     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5035     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5036     gc->pc += cmdlen;
5037     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5038 }
5039
5040 #define X_GLrop_MultiTexCoord1fvARB 199
5041 void
5042 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
5043 {
5044     __GLXcontext * const gc = __glXGetCurrentContext();
5045     const GLuint cmdlen = 12;
5046     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
5047     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5048     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
5049     gc->pc += cmdlen;
5050     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5051 }
5052
5053 #define X_GLrop_MultiTexCoord1ivARB 200
5054 void
5055 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
5056 {
5057     __GLXcontext * const gc = __glXGetCurrentContext();
5058     const GLuint cmdlen = 12;
5059     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
5060     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5061     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5062     gc->pc += cmdlen;
5063     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5064 }
5065
5066 #define X_GLrop_MultiTexCoord1ivARB 200
5067 void
5068 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
5069 {
5070     __GLXcontext * const gc = __glXGetCurrentContext();
5071     const GLuint cmdlen = 12;
5072     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
5073     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5074     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
5075     gc->pc += cmdlen;
5076     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5077 }
5078
5079 #define X_GLrop_MultiTexCoord1svARB 201
5080 void
5081 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
5082 {
5083     __GLXcontext * const gc = __glXGetCurrentContext();
5084     const GLuint cmdlen = 12;
5085     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
5086     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5087     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5088     gc->pc += cmdlen;
5089     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5090 }
5091
5092 #define X_GLrop_MultiTexCoord1svARB 201
5093 void
5094 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
5095 {
5096     __GLXcontext * const gc = __glXGetCurrentContext();
5097     const GLuint cmdlen = 12;
5098     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
5099     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5100     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
5101     gc->pc += cmdlen;
5102     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5103 }
5104
5105 #define X_GLrop_MultiTexCoord2dvARB 202
5106 void
5107 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
5108 {
5109     __GLXcontext * const gc = __glXGetCurrentContext();
5110     const GLuint cmdlen = 24;
5111     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
5112     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5113     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5114     (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
5115     gc->pc += cmdlen;
5116     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5117 }
5118
5119 #define X_GLrop_MultiTexCoord2dvARB 202
5120 void
5121 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
5122 {
5123     __GLXcontext * const gc = __glXGetCurrentContext();
5124     const GLuint cmdlen = 24;
5125     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
5126     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
5127     (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
5128     gc->pc += cmdlen;
5129     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5130 }
5131
5132 #define X_GLrop_MultiTexCoord2fvARB 203
5133 void
5134 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
5135 {
5136     __GLXcontext * const gc = __glXGetCurrentContext();
5137     const GLuint cmdlen = 16;
5138     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
5139     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5140     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5141     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5142     gc->pc += cmdlen;
5143     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5144 }
5145
5146 #define X_GLrop_MultiTexCoord2fvARB 203
5147 void
5148 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
5149 {
5150     __GLXcontext * const gc = __glXGetCurrentContext();
5151     const GLuint cmdlen = 16;
5152     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
5153     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5154     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5155     gc->pc += cmdlen;
5156     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5157 }
5158
5159 #define X_GLrop_MultiTexCoord2ivARB 204
5160 void
5161 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
5162 {
5163     __GLXcontext * const gc = __glXGetCurrentContext();
5164     const GLuint cmdlen = 16;
5165     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, 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     gc->pc += cmdlen;
5170     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5171 }
5172
5173 #define X_GLrop_MultiTexCoord2ivARB 204
5174 void
5175 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
5176 {
5177     __GLXcontext * const gc = __glXGetCurrentContext();
5178     const GLuint cmdlen = 16;
5179     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
5180     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5181     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5182     gc->pc += cmdlen;
5183     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5184 }
5185
5186 #define X_GLrop_MultiTexCoord2svARB 205
5187 void
5188 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
5189 {
5190     __GLXcontext * const gc = __glXGetCurrentContext();
5191     const GLuint cmdlen = 12;
5192     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
5193     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5194     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5195     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5196     gc->pc += cmdlen;
5197     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5198 }
5199
5200 #define X_GLrop_MultiTexCoord2svARB 205
5201 void
5202 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
5203 {
5204     __GLXcontext * const gc = __glXGetCurrentContext();
5205     const GLuint cmdlen = 12;
5206     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
5207     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5208     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
5209     gc->pc += cmdlen;
5210     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5211 }
5212
5213 #define X_GLrop_MultiTexCoord3dvARB 206
5214 void
5215 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
5216 {
5217     __GLXcontext * const gc = __glXGetCurrentContext();
5218     const GLuint cmdlen = 32;
5219     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5220     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5221     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5222     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5223     (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5224     gc->pc += cmdlen;
5225     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5226 }
5227
5228 #define X_GLrop_MultiTexCoord3dvARB 206
5229 void
5230 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
5231 {
5232     __GLXcontext * const gc = __glXGetCurrentContext();
5233     const GLuint cmdlen = 32;
5234     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5235     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
5236     (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5237     gc->pc += cmdlen;
5238     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5239 }
5240
5241 #define X_GLrop_MultiTexCoord3fvARB 207
5242 void
5243 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
5244 {
5245     __GLXcontext * const gc = __glXGetCurrentContext();
5246     const GLuint cmdlen = 20;
5247     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5248     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5249     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5250     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5251     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5252     gc->pc += cmdlen;
5253     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5254 }
5255
5256 #define X_GLrop_MultiTexCoord3fvARB 207
5257 void
5258 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
5259 {
5260     __GLXcontext * const gc = __glXGetCurrentContext();
5261     const GLuint cmdlen = 20;
5262     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5263     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5264     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5265     gc->pc += cmdlen;
5266     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5267 }
5268
5269 #define X_GLrop_MultiTexCoord3ivARB 208
5270 void
5271 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
5272 {
5273     __GLXcontext * const gc = __glXGetCurrentContext();
5274     const GLuint cmdlen = 20;
5275     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5276     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5277     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5278     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5279     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5280     gc->pc += cmdlen;
5281     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5282 }
5283
5284 #define X_GLrop_MultiTexCoord3ivARB 208
5285 void
5286 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
5287 {
5288     __GLXcontext * const gc = __glXGetCurrentContext();
5289     const GLuint cmdlen = 20;
5290     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5291     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5292     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5293     gc->pc += cmdlen;
5294     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5295 }
5296
5297 #define X_GLrop_MultiTexCoord3svARB 209
5298 void
5299 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
5300 {
5301     __GLXcontext * const gc = __glXGetCurrentContext();
5302     const GLuint cmdlen = 16;
5303     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5304     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5305     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5306     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5307     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5308     gc->pc += cmdlen;
5309     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5310 }
5311
5312 #define X_GLrop_MultiTexCoord3svARB 209
5313 void
5314 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
5315 {
5316     __GLXcontext * const gc = __glXGetCurrentContext();
5317     const GLuint cmdlen = 16;
5318     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5319     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5320     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
5321     gc->pc += cmdlen;
5322     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5323 }
5324
5325 #define X_GLrop_MultiTexCoord4dvARB 210
5326 void
5327 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
5328 {
5329     __GLXcontext * const gc = __glXGetCurrentContext();
5330     const GLuint cmdlen = 40;
5331     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5332     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5333     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5334     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5335     (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
5336     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5337     gc->pc += cmdlen;
5338     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5339 }
5340
5341 #define X_GLrop_MultiTexCoord4dvARB 210
5342 void
5343 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
5344 {
5345     __GLXcontext * const gc = __glXGetCurrentContext();
5346     const GLuint cmdlen = 40;
5347     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5348     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
5349     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5350     gc->pc += cmdlen;
5351     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5352 }
5353
5354 #define X_GLrop_MultiTexCoord4fvARB 211
5355 void
5356 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
5357 {
5358     __GLXcontext * const gc = __glXGetCurrentContext();
5359     const GLuint cmdlen = 24;
5360     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5361     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5362     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5363     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5364     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5365     (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5366     gc->pc += cmdlen;
5367     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5368 }
5369
5370 #define X_GLrop_MultiTexCoord4fvARB 211
5371 void
5372 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
5373 {
5374     __GLXcontext * const gc = __glXGetCurrentContext();
5375     const GLuint cmdlen = 24;
5376     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5377     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5378     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5379     gc->pc += cmdlen;
5380     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5381 }
5382
5383 #define X_GLrop_MultiTexCoord4ivARB 212
5384 void
5385 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
5386 {
5387     __GLXcontext * const gc = __glXGetCurrentContext();
5388     const GLuint cmdlen = 24;
5389     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5390     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5391     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5392     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5393     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5394     (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5395     gc->pc += cmdlen;
5396     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5397 }
5398
5399 #define X_GLrop_MultiTexCoord4ivARB 212
5400 void
5401 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
5402 {
5403     __GLXcontext * const gc = __glXGetCurrentContext();
5404     const GLuint cmdlen = 24;
5405     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5406     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5407     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5408     gc->pc += cmdlen;
5409     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5410 }
5411
5412 #define X_GLrop_MultiTexCoord4svARB 213
5413 void
5414 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
5415 {
5416     __GLXcontext * const gc = __glXGetCurrentContext();
5417     const GLuint cmdlen = 16;
5418     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
5419     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5420     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5421     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5422     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5423     (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
5424     gc->pc += cmdlen;
5425     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5426 }
5427
5428 #define X_GLrop_MultiTexCoord4svARB 213
5429 void
5430 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
5431 {
5432     __GLXcontext * const gc = __glXGetCurrentContext();
5433     const GLuint cmdlen = 16;
5434     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
5435     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5436     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5437     gc->pc += cmdlen;
5438     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5439 }
5440
5441 #define X_GLrop_SampleCoverageARB 229
5442 void
5443 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
5444 {
5445     __GLXcontext * const gc = __glXGetCurrentContext();
5446     const GLuint cmdlen = 12;
5447     emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
5448     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5449     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5450     gc->pc += cmdlen;
5451     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5452 }
5453
5454 #define X_GLrop_DrawBuffersARB 233
5455 void
5456 __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
5457 {
5458     __GLXcontext * const gc = __glXGetCurrentContext();
5459     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
5460     if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
5461         if (cmdlen <= gc->maxSmallRenderCommandSize) {
5462             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
5463                 (void) __glXFlushRenderBuffer(gc, gc->pc);
5464             }
5465             emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
5466             (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
5467             (void) memcpy((void *)(gc->pc + 8), (void *)(bufs), (n * 4));
5468             gc->pc += cmdlen;
5469             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5470         }
5471         else {
5472             const GLint op = X_GLrop_DrawBuffersARB;
5473             const GLuint cmdlenLarge = cmdlen + 4;
5474             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
5475             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
5476             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
5477             (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
5478             __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
5479         }
5480     }
5481 }
5482
5483 #define X_GLvop_AreTexturesResidentEXT 11
5484 GLboolean
5485 __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
5486 {
5487     __GLXcontext * const gc = __glXGetCurrentContext();
5488     Display * const dpy = gc->currentDpy;
5489     GLboolean retval = (GLboolean) 0;
5490     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5491     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5492         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
5493         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5494         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
5495         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
5496         UnlockDisplay(dpy); SyncHandle();
5497     }
5498     return retval;
5499 }
5500
5501 #define X_GLvop_GenTexturesEXT 13
5502 void
5503 __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
5504 {
5505     __GLXcontext * const gc = __glXGetCurrentContext();
5506     Display * const dpy = gc->currentDpy;
5507     const GLuint cmdlen = 4;
5508     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5509         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
5510         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5511         (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5512         UnlockDisplay(dpy); SyncHandle();
5513     }
5514     return;
5515 }
5516
5517 #define X_GLvop_IsTextureEXT 14
5518 GLboolean
5519 __indirect_glIsTextureEXT(GLuint texture)
5520 {
5521     __GLXcontext * const gc = __glXGetCurrentContext();
5522     Display * const dpy = gc->currentDpy;
5523     GLboolean retval = (GLboolean) 0;
5524     const GLuint cmdlen = 4;
5525     if (__builtin_expect(dpy != NULL, 1)) {
5526         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
5527         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
5528         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5529         UnlockDisplay(dpy); SyncHandle();
5530     }
5531     return retval;
5532 }
5533
5534 #define X_GLrop_SampleMaskSGIS 2048
5535 void
5536 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
5537 {
5538     __GLXcontext * const gc = __glXGetCurrentContext();
5539     const GLuint cmdlen = 12;
5540     emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
5541     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5542     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5543     gc->pc += cmdlen;
5544     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5545 }
5546
5547 #define X_GLrop_SamplePatternSGIS 2049
5548 void
5549 __indirect_glSamplePatternSGIS(GLenum pattern)
5550 {
5551     __GLXcontext * const gc = __glXGetCurrentContext();
5552     const GLuint cmdlen = 8;
5553     emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
5554     (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
5555     gc->pc += cmdlen;
5556     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5557 }
5558
5559 #define X_GLrop_PointParameterfEXT 2065
5560 void
5561 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
5562 {
5563     __GLXcontext * const gc = __glXGetCurrentContext();
5564     const GLuint cmdlen = 12;
5565     emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
5566     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5567     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
5568     gc->pc += cmdlen;
5569     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5570 }
5571
5572 #define X_GLrop_PointParameterfvEXT 2066
5573 void
5574 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
5575 {
5576     __GLXcontext * const gc = __glXGetCurrentContext();
5577     const GLuint compsize = __glPointParameterfvEXT_size(pname);
5578     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5579     emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
5580     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5581     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5582     gc->pc += cmdlen;
5583     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5584 }
5585
5586 #define X_GLrop_WindowPos3fvMESA 230
5587 void
5588 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
5589 {
5590     __GLXcontext * const gc = __glXGetCurrentContext();
5591     const GLuint cmdlen = 16;
5592     emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
5593     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
5594     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
5595     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
5596     gc->pc += cmdlen;
5597     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5598 }
5599
5600 #define X_GLrop_WindowPos3fvMESA 230
5601 void
5602 __indirect_glWindowPos3fvMESA(const GLfloat * v)
5603 {
5604     generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
5605 }
5606
5607 #define X_GLrop_BlendFuncSeparateEXT 4134
5608 void
5609 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
5610 {
5611     __GLXcontext * const gc = __glXGetCurrentContext();
5612     const GLuint cmdlen = 20;
5613     emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
5614     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
5615     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
5616     (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
5617     (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
5618     gc->pc += cmdlen;
5619     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5620 }
5621
5622 #define X_GLrop_FogCoordfvEXT 4124
5623 void
5624 __indirect_glFogCoordfEXT(GLfloat coord)
5625 {
5626     __GLXcontext * const gc = __glXGetCurrentContext();
5627     const GLuint cmdlen = 8;
5628     emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
5629     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
5630     gc->pc += cmdlen;
5631     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5632 }
5633
5634 #define X_GLrop_FogCoordfvEXT 4124
5635 void
5636 __indirect_glFogCoordfvEXT(const GLfloat * coord)
5637 {
5638     generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
5639 }
5640
5641 #define X_GLrop_FogCoorddvEXT 4125
5642 void
5643 __indirect_glFogCoorddEXT(GLdouble coord)
5644 {
5645     __GLXcontext * const gc = __glXGetCurrentContext();
5646     const GLuint cmdlen = 12;
5647     emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
5648     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
5649     gc->pc += cmdlen;
5650     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5651 }
5652
5653 #define X_GLrop_FogCoorddvEXT 4125
5654 void
5655 __indirect_glFogCoorddvEXT(const GLdouble * coord)
5656 {
5657     generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
5658 }
5659
5660 #define X_GLrop_SecondaryColor3bvEXT 4126
5661 void
5662 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
5663 {
5664     __GLXcontext * const gc = __glXGetCurrentContext();
5665     const GLuint cmdlen = 8;
5666     emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
5667     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5668     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5669     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5670     gc->pc += cmdlen;
5671     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5672 }
5673
5674 #define X_GLrop_SecondaryColor3bvEXT 4126
5675 void
5676 __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
5677 {
5678     generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
5679 }
5680
5681 #define X_GLrop_SecondaryColor3dvEXT 4130
5682 void
5683 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
5684 {
5685     __GLXcontext * const gc = __glXGetCurrentContext();
5686     const GLuint cmdlen = 28;
5687     emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
5688     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
5689     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
5690     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
5691     gc->pc += cmdlen;
5692     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5693 }
5694
5695 #define X_GLrop_SecondaryColor3dvEXT 4130
5696 void
5697 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
5698 {
5699     generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
5700 }
5701
5702 #define X_GLrop_SecondaryColor3fvEXT 4129
5703 void
5704 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
5705 {
5706     __GLXcontext * const gc = __glXGetCurrentContext();
5707     const GLuint cmdlen = 16;
5708     emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
5709     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5710     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5711     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5712     gc->pc += cmdlen;
5713     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5714 }
5715
5716 #define X_GLrop_SecondaryColor3fvEXT 4129
5717 void
5718 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
5719 {
5720     generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
5721 }
5722
5723 #define X_GLrop_SecondaryColor3ivEXT 4128
5724 void
5725 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
5726 {
5727     __GLXcontext * const gc = __glXGetCurrentContext();
5728     const GLuint cmdlen = 16;
5729     emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
5730     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5731     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5732     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5733     gc->pc += cmdlen;
5734     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5735 }
5736
5737 #define X_GLrop_SecondaryColor3ivEXT 4128
5738 void
5739 __indirect_glSecondaryColor3ivEXT(const GLint * v)
5740 {
5741     generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
5742 }
5743
5744 #define X_GLrop_SecondaryColor3svEXT 4127
5745 void
5746 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
5747 {
5748     __GLXcontext * const gc = __glXGetCurrentContext();
5749     const GLuint cmdlen = 12;
5750     emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
5751     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5752     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5753     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5754     gc->pc += cmdlen;
5755     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5756 }
5757
5758 #define X_GLrop_SecondaryColor3svEXT 4127
5759 void
5760 __indirect_glSecondaryColor3svEXT(const GLshort * v)
5761 {
5762     generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
5763 }
5764
5765 #define X_GLrop_SecondaryColor3ubvEXT 4131
5766 void
5767 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
5768 {
5769     __GLXcontext * const gc = __glXGetCurrentContext();
5770     const GLuint cmdlen = 8;
5771     emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
5772     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5773     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5774     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5775     gc->pc += cmdlen;
5776     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5777 }
5778
5779 #define X_GLrop_SecondaryColor3ubvEXT 4131
5780 void
5781 __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
5782 {
5783     generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
5784 }
5785
5786 #define X_GLrop_SecondaryColor3uivEXT 4133
5787 void
5788 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
5789 {
5790     __GLXcontext * const gc = __glXGetCurrentContext();
5791     const GLuint cmdlen = 16;
5792     emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
5793     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5794     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5795     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5796     gc->pc += cmdlen;
5797     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5798 }
5799
5800 #define X_GLrop_SecondaryColor3uivEXT 4133
5801 void
5802 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
5803 {
5804     generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
5805 }
5806
5807 #define X_GLrop_SecondaryColor3usvEXT 4132
5808 void
5809 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
5810 {
5811     __GLXcontext * const gc = __glXGetCurrentContext();
5812     const GLuint cmdlen = 12;
5813     emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
5814     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5815     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5816     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5817     gc->pc += cmdlen;
5818     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5819 }
5820
5821 #define X_GLrop_SecondaryColor3usvEXT 4132
5822 void
5823 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
5824 {
5825     generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
5826 }
5827
5828 #define X_GLvop_AreProgramsResidentNV 1293
5829 GLboolean
5830 __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
5831 {
5832     __GLXcontext * const gc = __glXGetCurrentContext();
5833     Display * const dpy = gc->currentDpy;
5834     GLboolean retval = (GLboolean) 0;
5835     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5836     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5837         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
5838         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5839         (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
5840         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
5841         UnlockDisplay(dpy); SyncHandle();
5842     }
5843     return retval;
5844 }
5845
5846 #define X_GLrop_BindProgramNV 4180
5847 void
5848 __indirect_glBindProgramNV(GLenum target, GLuint id)
5849 {
5850     __GLXcontext * const gc = __glXGetCurrentContext();
5851     const GLuint cmdlen = 12;
5852     emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
5853     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5854     (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
5855     gc->pc += cmdlen;
5856     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5857 }
5858
5859 #define X_GLvop_DeleteProgramsNV 1294
5860 void
5861 __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * ids)
5862 {
5863     __GLXcontext * const gc = __glXGetCurrentContext();
5864     Display * const dpy = gc->currentDpy;
5865     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5866     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5867         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
5868         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5869         (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
5870         UnlockDisplay(dpy); SyncHandle();
5871     }
5872     return;
5873 }
5874
5875 #define X_GLrop_ExecuteProgramNV 4181
5876 void
5877 __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
5878 {
5879     __GLXcontext * const gc = __glXGetCurrentContext();
5880     const GLuint cmdlen = 28;
5881     emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
5882     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5883     (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
5884     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
5885     gc->pc += cmdlen;
5886     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5887 }
5888
5889 #define X_GLvop_GenProgramsNV 1295
5890 void
5891 __indirect_glGenProgramsNV(GLsizei n, GLuint * ids)
5892 {
5893     __GLXcontext * const gc = __glXGetCurrentContext();
5894     Display * const dpy = gc->currentDpy;
5895     const GLuint cmdlen = 4;
5896     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5897         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
5898         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5899         (void) __glXReadReply(dpy, 4, ids, GL_FALSE);
5900         UnlockDisplay(dpy); SyncHandle();
5901     }
5902     return;
5903 }
5904
5905 #define X_GLvop_GetProgramParameterdvNV 1297
5906 void
5907 __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
5908 {
5909     __GLXcontext * const gc = __glXGetCurrentContext();
5910     Display * const dpy = gc->currentDpy;
5911     const GLuint cmdlen = 12;
5912     if (__builtin_expect(dpy != NULL, 1)) {
5913         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
5914         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5915         (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
5916         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
5917         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
5918         UnlockDisplay(dpy); SyncHandle();
5919     }
5920     return;
5921 }
5922
5923 #define X_GLvop_GetProgramParameterfvNV 1296
5924 void
5925 __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
5926 {
5927     __GLXcontext * const gc = __glXGetCurrentContext();
5928     Display * const dpy = gc->currentDpy;
5929     const GLuint cmdlen = 12;
5930     if (__builtin_expect(dpy != NULL, 1)) {
5931         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
5932         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5933         (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
5934         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
5935         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5936         UnlockDisplay(dpy); SyncHandle();
5937     }
5938     return;
5939 }
5940
5941 #define X_GLvop_GetProgramivNV 1298
5942 void
5943 __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
5944 {
5945     __GLXcontext * const gc = __glXGetCurrentContext();
5946     Display * const dpy = gc->currentDpy;
5947     const GLuint cmdlen = 8;
5948     if (__builtin_expect(dpy != NULL, 1)) {
5949         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
5950         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
5951         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5952         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5953         UnlockDisplay(dpy); SyncHandle();
5954     }
5955     return;
5956 }
5957
5958 #define X_GLvop_GetProgramStringNV 1299
5959 void
5960 __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
5961 {
5962     __GLXcontext * const gc = __glXGetCurrentContext();
5963     Display * const dpy = gc->currentDpy;
5964     const GLuint cmdlen = 8;
5965     if (__builtin_expect(dpy != NULL, 1)) {
5966         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
5967         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
5968         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5969         (void) __glXReadReply(dpy, 1, program, GL_TRUE);
5970         UnlockDisplay(dpy); SyncHandle();
5971     }
5972     return;
5973 }
5974
5975 #define X_GLvop_GetTrackMatrixivNV 1300
5976 void
5977 __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
5978 {
5979     __GLXcontext * const gc = __glXGetCurrentContext();
5980     Display * const dpy = gc->currentDpy;
5981     const GLuint cmdlen = 12;
5982     if (__builtin_expect(dpy != NULL, 1)) {
5983         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
5984         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5985         (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
5986         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
5987         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5988         UnlockDisplay(dpy); SyncHandle();
5989     }
5990     return;
5991 }
5992
5993 #define X_GLvop_IsProgramNV 1304
5994 GLboolean
5995 __indirect_glIsProgramNV(GLuint id)
5996 {
5997     __GLXcontext * const gc = __glXGetCurrentContext();
5998     Display * const dpy = gc->currentDpy;
5999     GLboolean retval = (GLboolean) 0;
6000     const GLuint cmdlen = 4;
6001     if (__builtin_expect(dpy != NULL, 1)) {
6002         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
6003         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
6004         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
6005         UnlockDisplay(dpy); SyncHandle();
6006     }
6007     return retval;
6008 }
6009
6010 #define X_GLrop_LoadProgramNV 4183
6011 void
6012 __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
6013 {
6014     __GLXcontext * const gc = __glXGetCurrentContext();
6015     const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
6016     if (__builtin_expect(len >= 0, 1)) {
6017         emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
6018         (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6019         (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
6020         (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
6021         (void) memcpy((void *)(gc->pc + 16), (void *)(program), (len * 1));
6022         gc->pc += cmdlen;
6023         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6024     }
6025 }
6026
6027 #define X_GLrop_ProgramParameter4dvNV 4185
6028 void
6029 __indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6030 {
6031     __GLXcontext * const gc = __glXGetCurrentContext();
6032     const GLuint cmdlen = 44;
6033     emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
6034     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6035     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6036     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6037     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6038     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6039     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6040     gc->pc += cmdlen;
6041     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6042 }
6043
6044 #define X_GLrop_ProgramParameter4dvNV 4185
6045 void
6046 __indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
6047 {
6048     __GLXcontext * const gc = __glXGetCurrentContext();
6049     const GLuint cmdlen = 44;
6050     emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
6051     (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
6052     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6053     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6054     gc->pc += cmdlen;
6055     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6056 }
6057
6058 #define X_GLrop_ProgramParameter4fvNV 4184
6059 void
6060 __indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6061 {
6062     __GLXcontext * const gc = __glXGetCurrentContext();
6063     const GLuint cmdlen = 28;
6064     emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
6065     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6066     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6067     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6068     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6069     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6070     (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6071     gc->pc += cmdlen;
6072     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6073 }
6074
6075 #define X_GLrop_ProgramParameter4fvNV 4184
6076 void
6077 __indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
6078 {
6079     __GLXcontext * const gc = __glXGetCurrentContext();
6080     const GLuint cmdlen = 28;
6081     emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
6082     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6083     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6084     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6085     gc->pc += cmdlen;
6086     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6087 }
6088
6089 #define X_GLrop_ProgramParameters4dvNV 4187
6090 void
6091 __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
6092 {
6093     __GLXcontext * const gc = __glXGetCurrentContext();
6094     const GLuint cmdlen = 16 + __GLX_PAD(((num * 4) * 8));
6095     if (__builtin_expect(num >= 0, 1)) {
6096         emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
6097         (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6098         (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6099         (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
6100         (void) memcpy((void *)(gc->pc + 16), (void *)(params), ((num * 4) * 8));
6101         gc->pc += cmdlen;
6102         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6103     }
6104 }
6105
6106 #define X_GLrop_ProgramParameters4fvNV 4186
6107 void
6108 __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
6109 {
6110     __GLXcontext * const gc = __glXGetCurrentContext();
6111     const GLuint cmdlen = 16 + __GLX_PAD(((num * 4) * 4));
6112     if (__builtin_expect(num >= 0, 1)) {
6113         emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
6114         (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6115         (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6116         (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
6117         (void) memcpy((void *)(gc->pc + 16), (void *)(params), ((num * 4) * 4));
6118         gc->pc += cmdlen;
6119         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6120     }
6121 }
6122
6123 #define X_GLrop_RequestResidentProgramsNV 4182
6124 void
6125 __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
6126 {
6127     __GLXcontext * const gc = __glXGetCurrentContext();
6128     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
6129     if (__builtin_expect(n >= 0, 1)) {
6130         emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
6131         (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
6132         (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
6133         gc->pc += cmdlen;
6134         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6135     }
6136 }
6137
6138 #define X_GLrop_TrackMatrixNV 4188
6139 void
6140 __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
6141 {
6142     __GLXcontext * const gc = __glXGetCurrentContext();
6143     const GLuint cmdlen = 20;
6144     emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
6145     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6146     (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
6147     (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
6148     (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
6149     gc->pc += cmdlen;
6150     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6151 }
6152
6153 #define X_GLrop_VertexAttrib1dvARB 4197
6154 void
6155 __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
6156 {
6157     __GLXcontext * const gc = __glXGetCurrentContext();
6158     const GLuint cmdlen = 16;
6159     emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
6160     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6161     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
6162     gc->pc += cmdlen;
6163     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6164 }
6165
6166 #define X_GLrop_VertexAttrib1dvARB 4197
6167 void
6168 __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
6169 {
6170     __GLXcontext * const gc = __glXGetCurrentContext();
6171     const GLuint cmdlen = 16;
6172     emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
6173     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
6174     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
6175     gc->pc += cmdlen;
6176     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6177 }
6178
6179 #define X_GLrop_VertexAttrib1fvARB 4193
6180 void
6181 __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
6182 {
6183     __GLXcontext * const gc = __glXGetCurrentContext();
6184     const GLuint cmdlen = 12;
6185     emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
6186     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6187     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6188     gc->pc += cmdlen;
6189     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6190 }
6191
6192 #define X_GLrop_VertexAttrib1fvARB 4193
6193 void
6194 __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
6195 {
6196     __GLXcontext * const gc = __glXGetCurrentContext();
6197     const GLuint cmdlen = 12;
6198     emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
6199     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6200     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6201     gc->pc += cmdlen;
6202     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6203 }
6204
6205 #define X_GLrop_VertexAttrib1svARB 4189
6206 void
6207 __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
6208 {
6209     __GLXcontext * const gc = __glXGetCurrentContext();
6210     const GLuint cmdlen = 12;
6211     emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
6212     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6213     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6214     gc->pc += cmdlen;
6215     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6216 }
6217
6218 #define X_GLrop_VertexAttrib1svARB 4189
6219 void
6220 __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
6221 {
6222     __GLXcontext * const gc = __glXGetCurrentContext();
6223     const GLuint cmdlen = 12;
6224     emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
6225     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6226     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
6227     gc->pc += cmdlen;
6228     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6229 }
6230
6231 #define X_GLrop_VertexAttrib2dvARB 4198
6232 void
6233 __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
6234 {
6235     __GLXcontext * const gc = __glXGetCurrentContext();
6236     const GLuint cmdlen = 24;
6237     emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
6238     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6239     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6240     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
6241     gc->pc += cmdlen;
6242     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6243 }
6244
6245 #define X_GLrop_VertexAttrib2dvARB 4198
6246 void
6247 __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
6248 {
6249     __GLXcontext * const gc = __glXGetCurrentContext();
6250     const GLuint cmdlen = 24;
6251     emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
6252     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
6253     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
6254     gc->pc += cmdlen;
6255     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6256 }
6257
6258 #define X_GLrop_VertexAttrib2fvARB 4194
6259 void
6260 __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
6261 {
6262     __GLXcontext * const gc = __glXGetCurrentContext();
6263     const GLuint cmdlen = 16;
6264     emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
6265     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6266     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6267     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6268     gc->pc += cmdlen;
6269     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6270 }
6271
6272 #define X_GLrop_VertexAttrib2fvARB 4194
6273 void
6274 __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
6275 {
6276     __GLXcontext * const gc = __glXGetCurrentContext();
6277     const GLuint cmdlen = 16;
6278     emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
6279     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6280     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6281     gc->pc += cmdlen;
6282     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6283 }
6284
6285 #define X_GLrop_VertexAttrib2svARB 4190
6286 void
6287 __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
6288 {
6289     __GLXcontext * const gc = __glXGetCurrentContext();
6290     const GLuint cmdlen = 12;
6291     emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
6292     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6293     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6294     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6295     gc->pc += cmdlen;
6296     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6297 }
6298
6299 #define X_GLrop_VertexAttrib2svARB 4190
6300 void
6301 __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
6302 {
6303     __GLXcontext * const gc = __glXGetCurrentContext();
6304     const GLuint cmdlen = 12;
6305     emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
6306     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6307     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6308     gc->pc += cmdlen;
6309     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6310 }
6311
6312 #define X_GLrop_VertexAttrib3dvARB 4199
6313 void
6314 __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
6315 {
6316     __GLXcontext * const gc = __glXGetCurrentContext();
6317     const GLuint cmdlen = 32;
6318     emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
6319     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6320     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6321     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6322     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
6323     gc->pc += cmdlen;
6324     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6325 }
6326
6327 #define X_GLrop_VertexAttrib3dvARB 4199
6328 void
6329 __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
6330 {
6331     __GLXcontext * const gc = __glXGetCurrentContext();
6332     const GLuint cmdlen = 32;
6333     emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
6334     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
6335     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
6336     gc->pc += cmdlen;
6337     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6338 }
6339
6340 #define X_GLrop_VertexAttrib3fvARB 4195
6341 void
6342 __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
6343 {
6344     __GLXcontext * const gc = __glXGetCurrentContext();
6345     const GLuint cmdlen = 20;
6346     emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
6347     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6348     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6349     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6350     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
6351     gc->pc += cmdlen;
6352     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6353 }
6354
6355 #define X_GLrop_VertexAttrib3fvARB 4195
6356 void
6357 __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
6358 {
6359     __GLXcontext * const gc = __glXGetCurrentContext();
6360     const GLuint cmdlen = 20;
6361     emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
6362     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6363     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
6364     gc->pc += cmdlen;
6365     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6366 }
6367
6368 #define X_GLrop_VertexAttrib3svARB 4191
6369 void
6370 __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
6371 {
6372     __GLXcontext * const gc = __glXGetCurrentContext();
6373     const GLuint cmdlen = 16;
6374     emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
6375     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6376     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6377     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6378     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
6379     gc->pc += cmdlen;
6380     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6381 }
6382
6383 #define X_GLrop_VertexAttrib3svARB 4191
6384 void
6385 __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
6386 {
6387     __GLXcontext * const gc = __glXGetCurrentContext();
6388     const GLuint cmdlen = 16;
6389     emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
6390     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6391     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
6392     gc->pc += cmdlen;
6393     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6394 }
6395
6396 #define X_GLrop_VertexAttrib4dvARB 4200
6397 void
6398 __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6399 {
6400     __GLXcontext * const gc = __glXGetCurrentContext();
6401     const GLuint cmdlen = 40;
6402     emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
6403     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6404     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6405     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6406     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6407     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
6408     gc->pc += cmdlen;
6409     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6410 }
6411
6412 #define X_GLrop_VertexAttrib4dvARB 4200
6413 void
6414 __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
6415 {
6416     __GLXcontext * const gc = __glXGetCurrentContext();
6417     const GLuint cmdlen = 40;
6418     emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
6419     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
6420     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
6421     gc->pc += cmdlen;
6422     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6423 }
6424
6425 #define X_GLrop_VertexAttrib4fvARB 4196
6426 void
6427 __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6428 {
6429     __GLXcontext * const gc = __glXGetCurrentContext();
6430     const GLuint cmdlen = 24;
6431     emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
6432     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6433     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6434     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6435     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
6436     (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
6437     gc->pc += cmdlen;
6438     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6439 }
6440
6441 #define X_GLrop_VertexAttrib4fvARB 4196
6442 void
6443 __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
6444 {
6445     __GLXcontext * const gc = __glXGetCurrentContext();
6446     const GLuint cmdlen = 24;
6447     emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
6448     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6449     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6450     gc->pc += cmdlen;
6451     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6452 }
6453
6454 #define X_GLrop_VertexAttrib4svARB 4192
6455 void
6456 __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
6457 {
6458     __GLXcontext * const gc = __glXGetCurrentContext();
6459     const GLuint cmdlen = 16;
6460     emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
6461     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6462     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6463     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6464     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
6465     (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
6466     gc->pc += cmdlen;
6467     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6468 }
6469
6470 #define X_GLrop_VertexAttrib4svARB 4192
6471 void
6472 __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
6473 {
6474     __GLXcontext * const gc = __glXGetCurrentContext();
6475     const GLuint cmdlen = 16;
6476     emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
6477     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6478     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6479     gc->pc += cmdlen;
6480     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6481 }
6482
6483 #define X_GLrop_VertexAttrib4NubvARB 4201
6484 void
6485 __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
6486 {
6487     __GLXcontext * const gc = __glXGetCurrentContext();
6488     const GLuint cmdlen = 12;
6489     emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
6490     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6491     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
6492     (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
6493     (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
6494     (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
6495     gc->pc += cmdlen;
6496     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6497 }
6498
6499 #define X_GLrop_VertexAttrib4NubvARB 4201
6500 void
6501 __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
6502 {
6503     __GLXcontext * const gc = __glXGetCurrentContext();
6504     const GLuint cmdlen = 12;
6505     emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
6506     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6507     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6508     gc->pc += cmdlen;
6509     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6510 }
6511
6512 #define X_GLrop_VertexAttribs1dvNV 4210
6513 void
6514 __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
6515 {
6516     __GLXcontext * const gc = __glXGetCurrentContext();
6517     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
6518     if (__builtin_expect(n >= 0, 1)) {
6519         emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
6520         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6521         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6522         (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
6523         gc->pc += cmdlen;
6524         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6525     }
6526 }
6527
6528 #define X_GLrop_VertexAttribs1fvNV 4206
6529 void
6530 __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
6531 {
6532     __GLXcontext * const gc = __glXGetCurrentContext();
6533     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
6534     if (__builtin_expect(n >= 0, 1)) {
6535         emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
6536         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6537         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6538         (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
6539         gc->pc += cmdlen;
6540         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6541     }
6542 }
6543
6544 #define X_GLrop_VertexAttribs1svNV 4202
6545 void
6546 __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
6547 {
6548     __GLXcontext * const gc = __glXGetCurrentContext();
6549     const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
6550     if (__builtin_expect(n >= 0, 1)) {
6551         emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
6552         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6553         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6554         (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
6555         gc->pc += cmdlen;
6556         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6557     }
6558 }
6559
6560 #define X_GLrop_VertexAttribs2dvNV 4211
6561 void
6562 __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
6563 {
6564     __GLXcontext * const gc = __glXGetCurrentContext();
6565     const GLuint cmdlen = 12 + __GLX_PAD(((n * 2) * 8));
6566     if (__builtin_expect(n >= 0, 1)) {
6567         emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
6568         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6569         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6570         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 2) * 8));
6571         gc->pc += cmdlen;
6572         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6573     }
6574 }
6575
6576 #define X_GLrop_VertexAttribs2fvNV 4207
6577 void
6578 __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
6579 {
6580     __GLXcontext * const gc = __glXGetCurrentContext();
6581     const GLuint cmdlen = 12 + __GLX_PAD(((n * 2) * 4));
6582     if (__builtin_expect(n >= 0, 1)) {
6583         emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
6584         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6585         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6586         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 2) * 4));
6587         gc->pc += cmdlen;
6588         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6589     }
6590 }
6591
6592 #define X_GLrop_VertexAttribs2svNV 4203
6593 void
6594 __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
6595 {
6596     __GLXcontext * const gc = __glXGetCurrentContext();
6597     const GLuint cmdlen = 12 + __GLX_PAD(((n * 2) * 2));
6598     if (__builtin_expect(n >= 0, 1)) {
6599         emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
6600         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6601         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6602         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 2) * 2));
6603         gc->pc += cmdlen;
6604         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6605     }
6606 }
6607
6608 #define X_GLrop_VertexAttribs3dvNV 4212
6609 void
6610 __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
6611 {
6612     __GLXcontext * const gc = __glXGetCurrentContext();
6613     const GLuint cmdlen = 12 + __GLX_PAD(((n * 3) * 8));
6614     if (__builtin_expect(n >= 0, 1)) {
6615         emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
6616         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6617         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6618         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 3) * 8));
6619         gc->pc += cmdlen;
6620         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6621     }
6622 }
6623
6624 #define X_GLrop_VertexAttribs3fvNV 4208
6625 void
6626 __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
6627 {
6628     __GLXcontext * const gc = __glXGetCurrentContext();
6629     const GLuint cmdlen = 12 + __GLX_PAD(((n * 3) * 4));
6630     if (__builtin_expect(n >= 0, 1)) {
6631         emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
6632         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6633         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6634         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 3) * 4));
6635         gc->pc += cmdlen;
6636         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6637     }
6638 }
6639
6640 #define X_GLrop_VertexAttribs3svNV 4204
6641 void
6642 __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
6643 {
6644     __GLXcontext * const gc = __glXGetCurrentContext();
6645     const GLuint cmdlen = 12 + __GLX_PAD(((n * 3) * 2));
6646     if (__builtin_expect(n >= 0, 1)) {
6647         emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
6648         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6649         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6650         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 3) * 2));
6651         gc->pc += cmdlen;
6652         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6653     }
6654 }
6655
6656 #define X_GLrop_VertexAttribs4dvNV 4213
6657 void
6658 __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
6659 {
6660     __GLXcontext * const gc = __glXGetCurrentContext();
6661     const GLuint cmdlen = 12 + __GLX_PAD(((n * 4) * 8));
6662     if (__builtin_expect(n >= 0, 1)) {
6663         emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
6664         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6665         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6666         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 4) * 8));
6667         gc->pc += cmdlen;
6668         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6669     }
6670 }
6671
6672 #define X_GLrop_VertexAttribs4fvNV 4209
6673 void
6674 __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
6675 {
6676     __GLXcontext * const gc = __glXGetCurrentContext();
6677     const GLuint cmdlen = 12 + __GLX_PAD(((n * 4) * 4));
6678     if (__builtin_expect(n >= 0, 1)) {
6679         emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
6680         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6681         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6682         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 4) * 4));
6683         gc->pc += cmdlen;
6684         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6685     }
6686 }
6687
6688 #define X_GLrop_VertexAttribs4svNV 4205
6689 void
6690 __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
6691 {
6692     __GLXcontext * const gc = __glXGetCurrentContext();
6693     const GLuint cmdlen = 12 + __GLX_PAD(((n * 4) * 2));
6694     if (__builtin_expect(n >= 0, 1)) {
6695         emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
6696         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6697         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6698         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 4) * 2));
6699         gc->pc += cmdlen;
6700         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6701     }
6702 }
6703
6704 #define X_GLrop_VertexAttribs4ubvNV 4214
6705 void
6706 __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
6707 {
6708     __GLXcontext * const gc = __glXGetCurrentContext();
6709     const GLuint cmdlen = 12 + __GLX_PAD(((n * 4) * 1));
6710     if (__builtin_expect(n >= 0, 1)) {
6711         emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
6712         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6713         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6714         (void) memcpy((void *)(gc->pc + 12), (void *)(v), ((n * 4) * 1));
6715         gc->pc += cmdlen;
6716         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6717     }
6718 }
6719
6720 #define X_GLrop_PointParameteriNV 4221
6721 void
6722 __indirect_glPointParameteriNV(GLenum pname, GLint params)
6723 {
6724     __GLXcontext * const gc = __glXGetCurrentContext();
6725     const GLuint cmdlen = 12;
6726     emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
6727     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
6728     (void) memcpy((void *)(gc->pc + 8), (void *)(&params), 4);
6729     gc->pc += cmdlen;
6730     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6731 }
6732
6733 #define X_GLrop_PointParameterivNV 4222
6734 void
6735 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
6736 {
6737     __GLXcontext * const gc = __glXGetCurrentContext();
6738     const GLuint compsize = __glPointParameterivNV_size(pname);
6739     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
6740     emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
6741     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
6742     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
6743     gc->pc += cmdlen;
6744     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6745 }
6746
6747 #define X_GLrop_ActiveStencilFaceEXT 4220
6748 void
6749 __indirect_glActiveStencilFaceEXT(GLenum face)
6750 {
6751     __GLXcontext * const gc = __glXGetCurrentContext();
6752     const GLuint cmdlen = 8;
6753     emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
6754     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
6755     gc->pc += cmdlen;
6756     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6757 }
6758
6759 #define X_GLrop_VertexAttrib4bvARB 4230
6760 void
6761 __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v)
6762 {
6763     __GLXcontext * const gc = __glXGetCurrentContext();
6764     const GLuint cmdlen = 12;
6765     emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
6766     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6767     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6768     gc->pc += cmdlen;
6769     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6770 }
6771
6772 #define X_GLrop_VertexAttrib4ivARB 4231
6773 void
6774 __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
6775 {
6776     __GLXcontext * const gc = __glXGetCurrentContext();
6777     const GLuint cmdlen = 24;
6778     emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
6779     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6780     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6781     gc->pc += cmdlen;
6782     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6783 }
6784
6785 #define X_GLrop_VertexAttrib4ubvARB 4232
6786 void
6787 __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
6788 {
6789     __GLXcontext * const gc = __glXGetCurrentContext();
6790     const GLuint cmdlen = 12;
6791     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
6792     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6793     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6794     gc->pc += cmdlen;
6795     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6796 }
6797
6798 #define X_GLrop_VertexAttrib4usvARB 4233
6799 void
6800 __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
6801 {
6802     __GLXcontext * const gc = __glXGetCurrentContext();
6803     const GLuint cmdlen = 16;
6804     emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
6805     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6806     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6807     gc->pc += cmdlen;
6808     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6809 }
6810
6811 #define X_GLrop_VertexAttrib4uivARB 4234
6812 void
6813 __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
6814 {
6815     __GLXcontext * const gc = __glXGetCurrentContext();
6816     const GLuint cmdlen = 24;
6817     emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
6818     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6819     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6820     gc->pc += cmdlen;
6821     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6822 }
6823
6824 #define X_GLrop_VertexAttrib4NbvARB 4235
6825 void
6826 __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
6827 {
6828     __GLXcontext * const gc = __glXGetCurrentContext();
6829     const GLuint cmdlen = 12;
6830     emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
6831     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6832     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6833     gc->pc += cmdlen;
6834     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6835 }
6836
6837 #define X_GLrop_VertexAttrib4NsvARB 4236
6838 void
6839 __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
6840 {
6841     __GLXcontext * const gc = __glXGetCurrentContext();
6842     const GLuint cmdlen = 16;
6843     emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
6844     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6845     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6846     gc->pc += cmdlen;
6847     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6848 }
6849
6850 #define X_GLrop_VertexAttrib4NivARB 4237
6851 void
6852 __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
6853 {
6854     __GLXcontext * const gc = __glXGetCurrentContext();
6855     const GLuint cmdlen = 24;
6856     emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
6857     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6858     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6859     gc->pc += cmdlen;
6860     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6861 }
6862
6863 #define X_GLrop_VertexAttrib4NusvARB 4238
6864 void
6865 __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
6866 {
6867     __GLXcontext * const gc = __glXGetCurrentContext();
6868     const GLuint cmdlen = 16;
6869     emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
6870     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6871     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6872     gc->pc += cmdlen;
6873     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6874 }
6875
6876 #define X_GLrop_VertexAttrib4NuivARB 4239
6877 void
6878 __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
6879 {
6880     __GLXcontext * const gc = __glXGetCurrentContext();
6881     const GLuint cmdlen = 24;
6882     emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
6883     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6884     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6885     gc->pc += cmdlen;
6886     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6887 }
6888
6889 #define X_GLrop_ProgramStringARB 4217
6890 void
6891 __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
6892 {
6893     __GLXcontext * const gc = __glXGetCurrentContext();
6894     const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
6895     if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
6896         if (cmdlen <= gc->maxSmallRenderCommandSize) {
6897             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
6898                 (void) __glXFlushRenderBuffer(gc, gc->pc);
6899             }
6900             emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
6901             (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6902             (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
6903             (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
6904             (void) memcpy((void *)(gc->pc + 16), (void *)(string), (len * 1));
6905             gc->pc += cmdlen;
6906             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6907         }
6908         else {
6909             const GLint op = X_GLrop_ProgramStringARB;
6910             const GLuint cmdlenLarge = cmdlen + 4;
6911             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
6912             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
6913             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
6914             (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
6915             (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
6916             (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
6917             __glXSendLargeCommand(gc, pc, 20, string, (len * 1));
6918         }
6919     }
6920 }
6921
6922 #define X_GLrop_ProgramEnvParameter4dvARB 4185
6923 void
6924 __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6925 {
6926     __GLXcontext * const gc = __glXGetCurrentContext();
6927     const GLuint cmdlen = 44;
6928     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
6929     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6930     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6931     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6932     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6933     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6934     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6935     gc->pc += cmdlen;
6936     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6937 }
6938
6939 #define X_GLrop_ProgramEnvParameter4dvARB 4185
6940 void
6941 __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
6942 {
6943     __GLXcontext * const gc = __glXGetCurrentContext();
6944     const GLuint cmdlen = 44;
6945     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
6946     (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
6947     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6948     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6949     gc->pc += cmdlen;
6950     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6951 }
6952
6953 #define X_GLrop_ProgramEnvParameter4fvARB 4184
6954 void
6955 __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6956 {
6957     __GLXcontext * const gc = __glXGetCurrentContext();
6958     const GLuint cmdlen = 28;
6959     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
6960     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6961     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6962     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6963     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6964     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6965     (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6966     gc->pc += cmdlen;
6967     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6968 }
6969
6970 #define X_GLrop_ProgramEnvParameter4fvARB 4184
6971 void
6972 __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
6973 {
6974     __GLXcontext * const gc = __glXGetCurrentContext();
6975     const GLuint cmdlen = 28;
6976     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
6977     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6978     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6979     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6980     gc->pc += cmdlen;
6981     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6982 }
6983
6984 #define X_GLrop_ProgramLocalParameter4dvARB 4216
6985 void
6986 __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6987 {
6988     __GLXcontext * const gc = __glXGetCurrentContext();
6989     const GLuint cmdlen = 44;
6990     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
6991     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6992     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6993     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6994     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6995     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6996     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6997     gc->pc += cmdlen;
6998     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6999 }
7000
7001 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7002 void
7003 __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
7004 {
7005     __GLXcontext * const gc = __glXGetCurrentContext();
7006     const GLuint cmdlen = 44;
7007     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7008     (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
7009     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
7010     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
7011     gc->pc += cmdlen;
7012     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7013 }
7014
7015 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7016 void
7017 __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7018 {
7019     __GLXcontext * const gc = __glXGetCurrentContext();
7020     const GLuint cmdlen = 28;
7021     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7022     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7023     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
7024     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
7025     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
7026     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
7027     (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
7028     gc->pc += cmdlen;
7029     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7030 }
7031
7032 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7033 void
7034 __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
7035 {
7036     __GLXcontext * const gc = __glXGetCurrentContext();
7037     const GLuint cmdlen = 28;
7038     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7039     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7040     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
7041     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
7042     gc->pc += cmdlen;
7043     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7044 }
7045
7046 #define X_GLvop_GetProgramivARB 1307
7047 void
7048 __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
7049 {
7050     __GLXcontext * const gc = __glXGetCurrentContext();
7051     Display * const dpy = gc->currentDpy;
7052     const GLuint cmdlen = 8;
7053     if (__builtin_expect(dpy != NULL, 1)) {
7054         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
7055         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7056         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7057         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7058         UnlockDisplay(dpy); SyncHandle();
7059     }
7060     return;
7061 }
7062
7063 #define X_GLvop_GetProgramStringARB 1308
7064 void
7065 __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
7066 {
7067     __GLXcontext * const gc = __glXGetCurrentContext();
7068     Display * const dpy = gc->currentDpy;
7069     const GLuint cmdlen = 8;
7070     if (__builtin_expect(dpy != NULL, 1)) {
7071         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
7072         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7073         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7074         (void) __glXReadReply(dpy, 1, string, GL_TRUE);
7075         UnlockDisplay(dpy); SyncHandle();
7076     }
7077     return;
7078 }
7079
7080 #define X_GLrop_ProgramNamedParameter4fvNV 4218
7081 void
7082 __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7083 {
7084     __GLXcontext * const gc = __glXGetCurrentContext();
7085     const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
7086     if (__builtin_expect(len >= 0, 1)) {
7087         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
7088         (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
7089         (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
7090         (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
7091         (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
7092         (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
7093         (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
7094         (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
7095         gc->pc += cmdlen;
7096         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7097     }
7098 }
7099
7100 #define X_GLrop_ProgramNamedParameter4dvNV 4219
7101 void
7102 __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7103 {
7104     __GLXcontext * const gc = __glXGetCurrentContext();
7105     const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
7106     if (__builtin_expect(len >= 0, 1)) {
7107         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
7108         (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7109         (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7110         (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
7111         (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
7112         (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
7113         (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
7114         (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
7115         gc->pc += cmdlen;
7116         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7117     }
7118 }
7119
7120 #define X_GLrop_ProgramNamedParameter4fvNV 4218
7121 void
7122 __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
7123 {
7124     __GLXcontext * const gc = __glXGetCurrentContext();
7125     const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
7126     if (__builtin_expect(len >= 0, 1)) {
7127         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
7128         (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
7129         (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
7130         (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
7131         (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
7132         gc->pc += cmdlen;
7133         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7134     }
7135 }
7136
7137 #define X_GLrop_ProgramNamedParameter4dvNV 4219
7138 void
7139 __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
7140 {
7141     __GLXcontext * const gc = __glXGetCurrentContext();
7142     const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
7143     if (__builtin_expect(len >= 0, 1)) {
7144         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
7145         (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
7146         (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
7147         (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
7148         (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
7149         gc->pc += cmdlen;
7150         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7151     }
7152 }
7153
7154 #define X_GLvop_GetProgramNamedParameterfvNV 1310
7155 void
7156 __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
7157 {
7158     __GLXcontext * const gc = __glXGetCurrentContext();
7159     Display * const dpy = gc->currentDpy;
7160     const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
7161     if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
7162         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
7163         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7164         (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
7165         (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
7166         (void) __glXReadReply(dpy, 4, params, GL_TRUE);
7167         UnlockDisplay(dpy); SyncHandle();
7168     }
7169     return;
7170 }
7171
7172 #define X_GLvop_GetProgramNamedParameterdvNV 1311
7173 void
7174 __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
7175 {
7176     __GLXcontext * const gc = __glXGetCurrentContext();
7177     Display * const dpy = gc->currentDpy;
7178     const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
7179     if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
7180         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
7181         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7182         (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
7183         (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
7184         (void) __glXReadReply(dpy, 8, params, GL_TRUE);
7185         UnlockDisplay(dpy); SyncHandle();
7186     }
7187     return;
7188 }
7189
7190 #define X_GLsop_GenQueriesARB 162
7191 void
7192 __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
7193 {
7194     __GLXcontext * const gc = __glXGetCurrentContext();
7195     Display * const dpy = gc->currentDpy;
7196     const GLuint cmdlen = 4;
7197     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
7198         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
7199         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
7200         (void) __glXReadReply(dpy, 4, ids, GL_FALSE);
7201         UnlockDisplay(dpy); SyncHandle();
7202     }
7203     return;
7204 }
7205
7206 #define X_GLsop_DeleteQueriesARB 161
7207 void
7208 __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
7209 {
7210     __GLXcontext * const gc = __glXGetCurrentContext();
7211     Display * const dpy = gc->currentDpy;
7212     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
7213     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
7214         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
7215         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
7216         (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
7217         UnlockDisplay(dpy); SyncHandle();
7218     }
7219     return;
7220 }
7221
7222 #define X_GLsop_IsQueryARB 163
7223 GLboolean
7224 __indirect_glIsQueryARB(GLuint id)
7225 {
7226     __GLXcontext * const gc = __glXGetCurrentContext();
7227     Display * const dpy = gc->currentDpy;
7228     GLboolean retval = (GLboolean) 0;
7229     const GLuint cmdlen = 4;
7230     if (__builtin_expect(dpy != NULL, 1)) {
7231         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
7232         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7233         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
7234         UnlockDisplay(dpy); SyncHandle();
7235     }
7236     return retval;
7237 }
7238
7239 #define X_GLrop_BeginQueryARB 231
7240 void
7241 __indirect_glBeginQueryARB(GLenum target, GLuint id)
7242 {
7243     __GLXcontext * const gc = __glXGetCurrentContext();
7244     const GLuint cmdlen = 12;
7245     emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
7246     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7247     (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
7248     gc->pc += cmdlen;
7249     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7250 }
7251
7252 #define X_GLrop_EndQueryARB 232
7253 void
7254 __indirect_glEndQueryARB(GLenum target)
7255 {
7256     __GLXcontext * const gc = __glXGetCurrentContext();
7257     const GLuint cmdlen = 8;
7258     emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
7259     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7260     gc->pc += cmdlen;
7261     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7262 }
7263
7264 #define X_GLsop_GetQueryivARB 164
7265 void
7266 __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
7267 {
7268     __GLXcontext * const gc = __glXGetCurrentContext();
7269     Display * const dpy = gc->currentDpy;
7270     const GLuint cmdlen = 8;
7271     if (__builtin_expect(dpy != NULL, 1)) {
7272         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
7273         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7274         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7275         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7276         UnlockDisplay(dpy); SyncHandle();
7277     }
7278     return;
7279 }
7280
7281 #define X_GLsop_GetQueryObjectivARB 165
7282 void
7283 __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
7284 {
7285     __GLXcontext * const gc = __glXGetCurrentContext();
7286     Display * const dpy = gc->currentDpy;
7287     const GLuint cmdlen = 8;
7288     if (__builtin_expect(dpy != NULL, 1)) {
7289         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
7290         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7291         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7292         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7293         UnlockDisplay(dpy); SyncHandle();
7294     }
7295     return;
7296 }
7297
7298 #define X_GLsop_GetQueryObjectuivARB 166
7299 void
7300 __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
7301 {
7302     __GLXcontext * const gc = __glXGetCurrentContext();
7303     Display * const dpy = gc->currentDpy;
7304     const GLuint cmdlen = 8;
7305     if (__builtin_expect(dpy != NULL, 1)) {
7306         GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
7307         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7308         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7309         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7310         UnlockDisplay(dpy); SyncHandle();
7311     }
7312     return;
7313 }
7314
7315 #define X_GLvop_GetVertexAttribdvNV 1301
7316 void
7317 __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
7318 {
7319     __GLXcontext * const gc = __glXGetCurrentContext();
7320     Display * const dpy = gc->currentDpy;
7321     const GLuint cmdlen = 8;
7322     if (__builtin_expect(dpy != NULL, 1)) {
7323         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
7324         (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7325         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7326         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
7327         UnlockDisplay(dpy); SyncHandle();
7328     }
7329     return;
7330 }
7331
7332 #define X_GLvop_GetVertexAttribfvNV 1302
7333 void
7334 __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
7335 {
7336     __GLXcontext * const gc = __glXGetCurrentContext();
7337     Display * const dpy = gc->currentDpy;
7338     const GLuint cmdlen = 8;
7339     if (__builtin_expect(dpy != NULL, 1)) {
7340         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
7341         (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7342         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7343         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7344         UnlockDisplay(dpy); SyncHandle();
7345     }
7346     return;
7347 }
7348
7349 #define X_GLvop_GetVertexAttribivNV 1303
7350 void
7351 __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
7352 {
7353     __GLXcontext * const gc = __glXGetCurrentContext();
7354     Display * const dpy = gc->currentDpy;
7355     const GLuint cmdlen = 8;
7356     if (__builtin_expect(dpy != NULL, 1)) {
7357         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
7358         (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7359         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7360         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7361         UnlockDisplay(dpy); SyncHandle();
7362     }
7363     return;
7364 }
7365
7366 #define X_GLrop_VertexAttrib1dvNV 4197
7367 void
7368 __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
7369 {
7370     __GLXcontext * const gc = __glXGetCurrentContext();
7371     const GLuint cmdlen = 16;
7372     emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
7373     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7374     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
7375     gc->pc += cmdlen;
7376     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7377 }
7378
7379 #define X_GLrop_VertexAttrib1dvNV 4197
7380 void
7381 __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
7382 {
7383     __GLXcontext * const gc = __glXGetCurrentContext();
7384     const GLuint cmdlen = 16;
7385     emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
7386     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
7387     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
7388     gc->pc += cmdlen;
7389     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7390 }
7391
7392 #define X_GLrop_VertexAttrib1fvNV 4193
7393 void
7394 __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
7395 {
7396     __GLXcontext * const gc = __glXGetCurrentContext();
7397     const GLuint cmdlen = 12;
7398     emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
7399     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7400     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7401     gc->pc += cmdlen;
7402     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7403 }
7404
7405 #define X_GLrop_VertexAttrib1fvNV 4193
7406 void
7407 __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
7408 {
7409     __GLXcontext * const gc = __glXGetCurrentContext();
7410     const GLuint cmdlen = 12;
7411     emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
7412     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7413     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7414     gc->pc += cmdlen;
7415     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7416 }
7417
7418 #define X_GLrop_VertexAttrib1svNV 4189
7419 void
7420 __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
7421 {
7422     __GLXcontext * const gc = __glXGetCurrentContext();
7423     const GLuint cmdlen = 12;
7424     emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
7425     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7426     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7427     gc->pc += cmdlen;
7428     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7429 }
7430
7431 #define X_GLrop_VertexAttrib1svNV 4189
7432 void
7433 __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
7434 {
7435     __GLXcontext * const gc = __glXGetCurrentContext();
7436     const GLuint cmdlen = 12;
7437     emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
7438     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7439     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
7440     gc->pc += cmdlen;
7441     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7442 }
7443
7444 #define X_GLrop_VertexAttrib2dvNV 4198
7445 void
7446 __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
7447 {
7448     __GLXcontext * const gc = __glXGetCurrentContext();
7449     const GLuint cmdlen = 24;
7450     emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
7451     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7452     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7453     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
7454     gc->pc += cmdlen;
7455     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7456 }
7457
7458 #define X_GLrop_VertexAttrib2dvNV 4198
7459 void
7460 __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
7461 {
7462     __GLXcontext * const gc = __glXGetCurrentContext();
7463     const GLuint cmdlen = 24;
7464     emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
7465     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
7466     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
7467     gc->pc += cmdlen;
7468     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7469 }
7470
7471 #define X_GLrop_VertexAttrib2fvNV 4194
7472 void
7473 __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
7474 {
7475     __GLXcontext * const gc = __glXGetCurrentContext();
7476     const GLuint cmdlen = 16;
7477     emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
7478     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7479     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7480     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7481     gc->pc += cmdlen;
7482     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7483 }
7484
7485 #define X_GLrop_VertexAttrib2fvNV 4194
7486 void
7487 __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
7488 {
7489     __GLXcontext * const gc = __glXGetCurrentContext();
7490     const GLuint cmdlen = 16;
7491     emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
7492     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7493     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7494     gc->pc += cmdlen;
7495     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7496 }
7497
7498 #define X_GLrop_VertexAttrib2svNV 4190
7499 void
7500 __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
7501 {
7502     __GLXcontext * const gc = __glXGetCurrentContext();
7503     const GLuint cmdlen = 12;
7504     emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
7505     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7506     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7507     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7508     gc->pc += cmdlen;
7509     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7510 }
7511
7512 #define X_GLrop_VertexAttrib2svNV 4190
7513 void
7514 __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
7515 {
7516     __GLXcontext * const gc = __glXGetCurrentContext();
7517     const GLuint cmdlen = 12;
7518     emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
7519     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7520     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7521     gc->pc += cmdlen;
7522     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7523 }
7524
7525 #define X_GLrop_VertexAttrib3dvNV 4199
7526 void
7527 __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
7528 {
7529     __GLXcontext * const gc = __glXGetCurrentContext();
7530     const GLuint cmdlen = 32;
7531     emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
7532     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7533     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7534     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
7535     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
7536     gc->pc += cmdlen;
7537     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7538 }
7539
7540 #define X_GLrop_VertexAttrib3dvNV 4199
7541 void
7542 __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
7543 {
7544     __GLXcontext * const gc = __glXGetCurrentContext();
7545     const GLuint cmdlen = 32;
7546     emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
7547     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
7548     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
7549     gc->pc += cmdlen;
7550     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7551 }
7552
7553 #define X_GLrop_VertexAttrib3fvNV 4195
7554 void
7555 __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
7556 {
7557     __GLXcontext * const gc = __glXGetCurrentContext();
7558     const GLuint cmdlen = 20;
7559     emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
7560     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7561     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7562     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7563     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
7564     gc->pc += cmdlen;
7565     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7566 }
7567
7568 #define X_GLrop_VertexAttrib3fvNV 4195
7569 void
7570 __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
7571 {
7572     __GLXcontext * const gc = __glXGetCurrentContext();
7573     const GLuint cmdlen = 20;
7574     emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
7575     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7576     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
7577     gc->pc += cmdlen;
7578     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7579 }
7580
7581 #define X_GLrop_VertexAttrib3svNV 4191
7582 void
7583 __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
7584 {
7585     __GLXcontext * const gc = __glXGetCurrentContext();
7586     const GLuint cmdlen = 16;
7587     emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
7588     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7589     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7590     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7591     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
7592     gc->pc += cmdlen;
7593     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7594 }
7595
7596 #define X_GLrop_VertexAttrib3svNV 4191
7597 void
7598 __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
7599 {
7600     __GLXcontext * const gc = __glXGetCurrentContext();
7601     const GLuint cmdlen = 16;
7602     emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
7603     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7604     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
7605     gc->pc += cmdlen;
7606     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7607 }
7608
7609 #define X_GLrop_VertexAttrib4dvNV 4200
7610 void
7611 __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7612 {
7613     __GLXcontext * const gc = __glXGetCurrentContext();
7614     const GLuint cmdlen = 40;
7615     emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
7616     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7617     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7618     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
7619     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
7620     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
7621     gc->pc += cmdlen;
7622     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7623 }
7624
7625 #define X_GLrop_VertexAttrib4dvNV 4200
7626 void
7627 __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
7628 {
7629     __GLXcontext * const gc = __glXGetCurrentContext();
7630     const GLuint cmdlen = 40;
7631     emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
7632     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
7633     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
7634     gc->pc += cmdlen;
7635     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7636 }
7637
7638 #define X_GLrop_VertexAttrib4fvNV 4196
7639 void
7640 __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7641 {
7642     __GLXcontext * const gc = __glXGetCurrentContext();
7643     const GLuint cmdlen = 24;
7644     emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
7645     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7646     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7647     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7648     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
7649     (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
7650     gc->pc += cmdlen;
7651     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7652 }
7653
7654 #define X_GLrop_VertexAttrib4fvNV 4196
7655 void
7656 __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
7657 {
7658     __GLXcontext * const gc = __glXGetCurrentContext();
7659     const GLuint cmdlen = 24;
7660     emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
7661     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7662     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
7663     gc->pc += cmdlen;
7664     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7665 }
7666
7667 #define X_GLrop_VertexAttrib4svNV 4192
7668 void
7669 __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
7670 {
7671     __GLXcontext * const gc = __glXGetCurrentContext();
7672     const GLuint cmdlen = 16;
7673     emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
7674     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7675     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7676     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7677     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
7678     (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
7679     gc->pc += cmdlen;
7680     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7681 }
7682
7683 #define X_GLrop_VertexAttrib4svNV 4192
7684 void
7685 __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
7686 {
7687     __GLXcontext * const gc = __glXGetCurrentContext();
7688     const GLuint cmdlen = 16;
7689     emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
7690     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7691     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7692     gc->pc += cmdlen;
7693     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7694 }
7695
7696 #define X_GLrop_VertexAttrib4ubvNV 4201
7697 void
7698 __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
7699 {
7700     __GLXcontext * const gc = __glXGetCurrentContext();
7701     const GLuint cmdlen = 12;
7702     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
7703     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7704     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
7705     (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
7706     (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
7707     (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
7708     gc->pc += cmdlen;
7709     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7710 }
7711
7712 #define X_GLrop_VertexAttrib4ubvNV 4201
7713 void
7714 __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
7715 {
7716     __GLXcontext * const gc = __glXGetCurrentContext();
7717     const GLuint cmdlen = 12;
7718     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
7719     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7720     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7721     gc->pc += cmdlen;
7722     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7723 }
7724