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_GLvop_AreTexturesResidentEXT 11
5455 GLboolean
5456 __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
5457 {
5458     __GLXcontext * const gc = __glXGetCurrentContext();
5459     Display * const dpy = gc->currentDpy;
5460     GLboolean retval = (GLboolean) 0;
5461     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5462     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5463         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
5464         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5465         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
5466         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
5467         UnlockDisplay(dpy); SyncHandle();
5468     }
5469     return retval;
5470 }
5471
5472 #define X_GLvop_GenTexturesEXT 13
5473 void
5474 __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
5475 {
5476     __GLXcontext * const gc = __glXGetCurrentContext();
5477     Display * const dpy = gc->currentDpy;
5478     const GLuint cmdlen = 4;
5479     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5480         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
5481         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5482         (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5483         UnlockDisplay(dpy); SyncHandle();
5484     }
5485     return;
5486 }
5487
5488 #define X_GLvop_IsTextureEXT 14
5489 GLboolean
5490 __indirect_glIsTextureEXT(GLuint texture)
5491 {
5492     __GLXcontext * const gc = __glXGetCurrentContext();
5493     Display * const dpy = gc->currentDpy;
5494     GLboolean retval = (GLboolean) 0;
5495     const GLuint cmdlen = 4;
5496     if (__builtin_expect(dpy != NULL, 1)) {
5497         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
5498         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
5499         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5500         UnlockDisplay(dpy); SyncHandle();
5501     }
5502     return retval;
5503 }
5504
5505 #define X_GLrop_SampleMaskSGIS 2048
5506 void
5507 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
5508 {
5509     __GLXcontext * const gc = __glXGetCurrentContext();
5510     const GLuint cmdlen = 12;
5511     emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
5512     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5513     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5514     gc->pc += cmdlen;
5515     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5516 }
5517
5518 #define X_GLrop_SamplePatternSGIS 2049
5519 void
5520 __indirect_glSamplePatternSGIS(GLenum pattern)
5521 {
5522     __GLXcontext * const gc = __glXGetCurrentContext();
5523     const GLuint cmdlen = 8;
5524     emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
5525     (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
5526     gc->pc += cmdlen;
5527     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5528 }
5529
5530 #define X_GLrop_PointParameterfEXT 2065
5531 void
5532 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
5533 {
5534     __GLXcontext * const gc = __glXGetCurrentContext();
5535     const GLuint cmdlen = 12;
5536     emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
5537     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5538     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
5539     gc->pc += cmdlen;
5540     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5541 }
5542
5543 #define X_GLrop_PointParameterfvEXT 2066
5544 void
5545 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
5546 {
5547     __GLXcontext * const gc = __glXGetCurrentContext();
5548     const GLuint compsize = __glPointParameterfvEXT_size(pname);
5549     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5550     emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
5551     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5552     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5553     gc->pc += cmdlen;
5554     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5555 }
5556
5557 #define X_GLrop_WindowPos3fvMESA 230
5558 void
5559 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
5560 {
5561     __GLXcontext * const gc = __glXGetCurrentContext();
5562     const GLuint cmdlen = 16;
5563     emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
5564     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
5565     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
5566     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
5567     gc->pc += cmdlen;
5568     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5569 }
5570
5571 #define X_GLrop_WindowPos3fvMESA 230
5572 void
5573 __indirect_glWindowPos3fvMESA(const GLfloat * v)
5574 {
5575     generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
5576 }
5577
5578 #define X_GLrop_BlendFuncSeparateEXT 4134
5579 void
5580 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
5581 {
5582     __GLXcontext * const gc = __glXGetCurrentContext();
5583     const GLuint cmdlen = 20;
5584     emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
5585     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
5586     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
5587     (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
5588     (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
5589     gc->pc += cmdlen;
5590     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5591 }
5592
5593 #define X_GLrop_FogCoordfvEXT 4124
5594 void
5595 __indirect_glFogCoordfEXT(GLfloat coord)
5596 {
5597     __GLXcontext * const gc = __glXGetCurrentContext();
5598     const GLuint cmdlen = 8;
5599     emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
5600     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
5601     gc->pc += cmdlen;
5602     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5603 }
5604
5605 #define X_GLrop_FogCoordfvEXT 4124
5606 void
5607 __indirect_glFogCoordfvEXT(const GLfloat * coord)
5608 {
5609     generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
5610 }
5611
5612 #define X_GLrop_FogCoorddvEXT 4125
5613 void
5614 __indirect_glFogCoorddEXT(GLdouble coord)
5615 {
5616     __GLXcontext * const gc = __glXGetCurrentContext();
5617     const GLuint cmdlen = 12;
5618     emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
5619     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
5620     gc->pc += cmdlen;
5621     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5622 }
5623
5624 #define X_GLrop_FogCoorddvEXT 4125
5625 void
5626 __indirect_glFogCoorddvEXT(const GLdouble * coord)
5627 {
5628     generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
5629 }
5630
5631 #define X_GLrop_SecondaryColor3bvEXT 4126
5632 void
5633 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
5634 {
5635     __GLXcontext * const gc = __glXGetCurrentContext();
5636     const GLuint cmdlen = 8;
5637     emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
5638     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5639     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5640     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5641     gc->pc += cmdlen;
5642     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5643 }
5644
5645 #define X_GLrop_SecondaryColor3bvEXT 4126
5646 void
5647 __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
5648 {
5649     generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
5650 }
5651
5652 #define X_GLrop_SecondaryColor3dvEXT 4130
5653 void
5654 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
5655 {
5656     __GLXcontext * const gc = __glXGetCurrentContext();
5657     const GLuint cmdlen = 28;
5658     emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
5659     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
5660     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
5661     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
5662     gc->pc += cmdlen;
5663     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5664 }
5665
5666 #define X_GLrop_SecondaryColor3dvEXT 4130
5667 void
5668 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
5669 {
5670     generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
5671 }
5672
5673 #define X_GLrop_SecondaryColor3fvEXT 4129
5674 void
5675 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
5676 {
5677     __GLXcontext * const gc = __glXGetCurrentContext();
5678     const GLuint cmdlen = 16;
5679     emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
5680     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5681     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5682     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5683     gc->pc += cmdlen;
5684     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5685 }
5686
5687 #define X_GLrop_SecondaryColor3fvEXT 4129
5688 void
5689 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
5690 {
5691     generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
5692 }
5693
5694 #define X_GLrop_SecondaryColor3ivEXT 4128
5695 void
5696 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
5697 {
5698     __GLXcontext * const gc = __glXGetCurrentContext();
5699     const GLuint cmdlen = 16;
5700     emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
5701     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5702     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5703     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5704     gc->pc += cmdlen;
5705     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5706 }
5707
5708 #define X_GLrop_SecondaryColor3ivEXT 4128
5709 void
5710 __indirect_glSecondaryColor3ivEXT(const GLint * v)
5711 {
5712     generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
5713 }
5714
5715 #define X_GLrop_SecondaryColor3svEXT 4127
5716 void
5717 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
5718 {
5719     __GLXcontext * const gc = __glXGetCurrentContext();
5720     const GLuint cmdlen = 12;
5721     emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
5722     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5723     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5724     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5725     gc->pc += cmdlen;
5726     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5727 }
5728
5729 #define X_GLrop_SecondaryColor3svEXT 4127
5730 void
5731 __indirect_glSecondaryColor3svEXT(const GLshort * v)
5732 {
5733     generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
5734 }
5735
5736 #define X_GLrop_SecondaryColor3ubvEXT 4131
5737 void
5738 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
5739 {
5740     __GLXcontext * const gc = __glXGetCurrentContext();
5741     const GLuint cmdlen = 8;
5742     emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
5743     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5744     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5745     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5746     gc->pc += cmdlen;
5747     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5748 }
5749
5750 #define X_GLrop_SecondaryColor3ubvEXT 4131
5751 void
5752 __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
5753 {
5754     generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
5755 }
5756
5757 #define X_GLrop_SecondaryColor3uivEXT 4133
5758 void
5759 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
5760 {
5761     __GLXcontext * const gc = __glXGetCurrentContext();
5762     const GLuint cmdlen = 16;
5763     emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
5764     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5765     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5766     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5767     gc->pc += cmdlen;
5768     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5769 }
5770
5771 #define X_GLrop_SecondaryColor3uivEXT 4133
5772 void
5773 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
5774 {
5775     generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
5776 }
5777
5778 #define X_GLrop_SecondaryColor3usvEXT 4132
5779 void
5780 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
5781 {
5782     __GLXcontext * const gc = __glXGetCurrentContext();
5783     const GLuint cmdlen = 12;
5784     emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
5785     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5786     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5787     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5788     gc->pc += cmdlen;
5789     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5790 }
5791
5792 #define X_GLrop_SecondaryColor3usvEXT 4132
5793 void
5794 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
5795 {
5796     generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
5797 }
5798
5799 #define X_GLvop_AreProgramsResidentNV 1293
5800 GLboolean
5801 __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
5802 {
5803     __GLXcontext * const gc = __glXGetCurrentContext();
5804     Display * const dpy = gc->currentDpy;
5805     GLboolean retval = (GLboolean) 0;
5806     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5807     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5808         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
5809         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5810         (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
5811         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
5812         UnlockDisplay(dpy); SyncHandle();
5813     }
5814     return retval;
5815 }
5816
5817 #define X_GLrop_BindProgramNV 4180
5818 void
5819 __indirect_glBindProgramNV(GLenum target, GLuint id)
5820 {
5821     __GLXcontext * const gc = __glXGetCurrentContext();
5822     const GLuint cmdlen = 12;
5823     emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
5824     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5825     (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
5826     gc->pc += cmdlen;
5827     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5828 }
5829
5830 #define X_GLvop_DeleteProgramsNV 1294
5831 void
5832 __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * ids)
5833 {
5834     __GLXcontext * const gc = __glXGetCurrentContext();
5835     Display * const dpy = gc->currentDpy;
5836     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5837     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5838         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
5839         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5840         (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
5841         UnlockDisplay(dpy); SyncHandle();
5842     }
5843     return;
5844 }
5845
5846 #define X_GLrop_ExecuteProgramNV 4181
5847 void
5848 __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
5849 {
5850     __GLXcontext * const gc = __glXGetCurrentContext();
5851     const GLuint cmdlen = 28;
5852     emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
5853     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5854     (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
5855     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
5856     gc->pc += cmdlen;
5857     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5858 }
5859
5860 #define X_GLvop_GenProgramsNV 1295
5861 void
5862 __indirect_glGenProgramsNV(GLsizei n, GLuint * ids)
5863 {
5864     __GLXcontext * const gc = __glXGetCurrentContext();
5865     Display * const dpy = gc->currentDpy;
5866     const GLuint cmdlen = 4;
5867     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5868         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
5869         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5870         (void) __glXReadReply(dpy, 4, ids, GL_FALSE);
5871         UnlockDisplay(dpy); SyncHandle();
5872     }
5873     return;
5874 }
5875
5876 #define X_GLvop_GetProgramParameterdvNV 1297
5877 void
5878 __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
5879 {
5880     __GLXcontext * const gc = __glXGetCurrentContext();
5881     Display * const dpy = gc->currentDpy;
5882     const GLuint cmdlen = 12;
5883     if (__builtin_expect(dpy != NULL, 1)) {
5884         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
5885         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5886         (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
5887         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
5888         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
5889         UnlockDisplay(dpy); SyncHandle();
5890     }
5891     return;
5892 }
5893
5894 #define X_GLvop_GetProgramParameterfvNV 1296
5895 void
5896 __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
5897 {
5898     __GLXcontext * const gc = __glXGetCurrentContext();
5899     Display * const dpy = gc->currentDpy;
5900     const GLuint cmdlen = 12;
5901     if (__builtin_expect(dpy != NULL, 1)) {
5902         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
5903         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5904         (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
5905         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
5906         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5907         UnlockDisplay(dpy); SyncHandle();
5908     }
5909     return;
5910 }
5911
5912 #define X_GLvop_GetProgramivNV 1298
5913 void
5914 __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
5915 {
5916     __GLXcontext * const gc = __glXGetCurrentContext();
5917     Display * const dpy = gc->currentDpy;
5918     const GLuint cmdlen = 8;
5919     if (__builtin_expect(dpy != NULL, 1)) {
5920         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
5921         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
5922         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5923         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5924         UnlockDisplay(dpy); SyncHandle();
5925     }
5926     return;
5927 }
5928
5929 #define X_GLvop_GetProgramStringNV 1299
5930 void
5931 __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
5932 {
5933     __GLXcontext * const gc = __glXGetCurrentContext();
5934     Display * const dpy = gc->currentDpy;
5935     const GLuint cmdlen = 8;
5936     if (__builtin_expect(dpy != NULL, 1)) {
5937         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
5938         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
5939         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5940         (void) __glXReadReply(dpy, 1, program, GL_TRUE);
5941         UnlockDisplay(dpy); SyncHandle();
5942     }
5943     return;
5944 }
5945
5946 #define X_GLvop_GetTrackMatrixivNV 1300
5947 void
5948 __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
5949 {
5950     __GLXcontext * const gc = __glXGetCurrentContext();
5951     Display * const dpy = gc->currentDpy;
5952     const GLuint cmdlen = 12;
5953     if (__builtin_expect(dpy != NULL, 1)) {
5954         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
5955         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5956         (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
5957         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
5958         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5959         UnlockDisplay(dpy); SyncHandle();
5960     }
5961     return;
5962 }
5963
5964 #define X_GLvop_IsProgramNV 1304
5965 GLboolean
5966 __indirect_glIsProgramNV(GLuint id)
5967 {
5968     __GLXcontext * const gc = __glXGetCurrentContext();
5969     Display * const dpy = gc->currentDpy;
5970     GLboolean retval = (GLboolean) 0;
5971     const GLuint cmdlen = 4;
5972     if (__builtin_expect(dpy != NULL, 1)) {
5973         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
5974         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
5975         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5976         UnlockDisplay(dpy); SyncHandle();
5977     }
5978     return retval;
5979 }
5980
5981 #define X_GLrop_LoadProgramNV 4183
5982 void
5983 __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
5984 {
5985     __GLXcontext * const gc = __glXGetCurrentContext();
5986     const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
5987     if (__builtin_expect(len >= 0, 1)) {
5988         emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
5989         (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5990         (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
5991         (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
5992         (void) memcpy((void *)(gc->pc + 16), (void *)(program), (len * 1));
5993         gc->pc += cmdlen;
5994         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5995     }
5996 }
5997
5998 #define X_GLrop_ProgramParameter4dvNV 4185
5999 void
6000 __indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6001 {
6002     __GLXcontext * const gc = __glXGetCurrentContext();
6003     const GLuint cmdlen = 44;
6004     emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
6005     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6006     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6007     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6008     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6009     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6010     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6011     gc->pc += cmdlen;
6012     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6013 }
6014
6015 #define X_GLrop_ProgramParameter4dvNV 4185
6016 void
6017 __indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
6018 {
6019     __GLXcontext * const gc = __glXGetCurrentContext();
6020     const GLuint cmdlen = 44;
6021     emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
6022     (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
6023     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6024     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6025     gc->pc += cmdlen;
6026     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6027 }
6028
6029 #define X_GLrop_ProgramParameter4fvNV 4184
6030 void
6031 __indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6032 {
6033     __GLXcontext * const gc = __glXGetCurrentContext();
6034     const GLuint cmdlen = 28;
6035     emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
6036     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6037     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6038     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6039     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6040     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6041     (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6042     gc->pc += cmdlen;
6043     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6044 }
6045
6046 #define X_GLrop_ProgramParameter4fvNV 4184
6047 void
6048 __indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
6049 {
6050     __GLXcontext * const gc = __glXGetCurrentContext();
6051     const GLuint cmdlen = 28;
6052     emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
6053     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6054     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6055     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6056     gc->pc += cmdlen;
6057     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6058 }
6059
6060 #define X_GLrop_ProgramParameters4dvNV 4187
6061 void
6062 __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
6063 {
6064     __GLXcontext * const gc = __glXGetCurrentContext();
6065     const GLuint cmdlen = 16 + __GLX_PAD((num * 8));
6066     emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
6067     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6068     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6069     (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
6070     (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 8));
6071     gc->pc += cmdlen;
6072     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6073 }
6074
6075 #define X_GLrop_ProgramParameters4fvNV 4186
6076 void
6077 __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
6078 {
6079     __GLXcontext * const gc = __glXGetCurrentContext();
6080     const GLuint cmdlen = 16 + __GLX_PAD((num * 4));
6081     if (__builtin_expect(num >= 0, 1)) {
6082         emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
6083         (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6084         (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6085         (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
6086         (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 4));
6087         gc->pc += cmdlen;
6088         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6089     }
6090 }
6091
6092 #define X_GLrop_RequestResidentProgramsNV 4182
6093 void
6094 __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
6095 {
6096     __GLXcontext * const gc = __glXGetCurrentContext();
6097     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
6098     if (__builtin_expect(n >= 0, 1)) {
6099         emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
6100         (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
6101         (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
6102         gc->pc += cmdlen;
6103         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6104     }
6105 }
6106
6107 #define X_GLrop_TrackMatrixNV 4188
6108 void
6109 __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
6110 {
6111     __GLXcontext * const gc = __glXGetCurrentContext();
6112     const GLuint cmdlen = 20;
6113     emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
6114     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6115     (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
6116     (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
6117     (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
6118     gc->pc += cmdlen;
6119     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6120 }
6121
6122 #define X_GLrop_VertexAttrib1dvARB 4197
6123 void
6124 __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
6125 {
6126     __GLXcontext * const gc = __glXGetCurrentContext();
6127     const GLuint cmdlen = 16;
6128     emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
6129     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6130     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
6131     gc->pc += cmdlen;
6132     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6133 }
6134
6135 #define X_GLrop_VertexAttrib1dvARB 4197
6136 void
6137 __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
6138 {
6139     __GLXcontext * const gc = __glXGetCurrentContext();
6140     const GLuint cmdlen = 16;
6141     emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
6142     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
6143     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
6144     gc->pc += cmdlen;
6145     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6146 }
6147
6148 #define X_GLrop_VertexAttrib1fvARB 4193
6149 void
6150 __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
6151 {
6152     __GLXcontext * const gc = __glXGetCurrentContext();
6153     const GLuint cmdlen = 12;
6154     emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
6155     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6156     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6157     gc->pc += cmdlen;
6158     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6159 }
6160
6161 #define X_GLrop_VertexAttrib1fvARB 4193
6162 void
6163 __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
6164 {
6165     __GLXcontext * const gc = __glXGetCurrentContext();
6166     const GLuint cmdlen = 12;
6167     emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
6168     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6169     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6170     gc->pc += cmdlen;
6171     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6172 }
6173
6174 #define X_GLrop_VertexAttrib1svARB 4189
6175 void
6176 __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
6177 {
6178     __GLXcontext * const gc = __glXGetCurrentContext();
6179     const GLuint cmdlen = 12;
6180     emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
6181     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6182     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6183     gc->pc += cmdlen;
6184     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6185 }
6186
6187 #define X_GLrop_VertexAttrib1svARB 4189
6188 void
6189 __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
6190 {
6191     __GLXcontext * const gc = __glXGetCurrentContext();
6192     const GLuint cmdlen = 12;
6193     emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
6194     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6195     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
6196     gc->pc += cmdlen;
6197     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6198 }
6199
6200 #define X_GLrop_VertexAttrib2dvARB 4198
6201 void
6202 __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
6203 {
6204     __GLXcontext * const gc = __glXGetCurrentContext();
6205     const GLuint cmdlen = 24;
6206     emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
6207     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6208     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6209     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
6210     gc->pc += cmdlen;
6211     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6212 }
6213
6214 #define X_GLrop_VertexAttrib2dvARB 4198
6215 void
6216 __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
6217 {
6218     __GLXcontext * const gc = __glXGetCurrentContext();
6219     const GLuint cmdlen = 24;
6220     emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
6221     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
6222     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
6223     gc->pc += cmdlen;
6224     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6225 }
6226
6227 #define X_GLrop_VertexAttrib2fvARB 4194
6228 void
6229 __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
6230 {
6231     __GLXcontext * const gc = __glXGetCurrentContext();
6232     const GLuint cmdlen = 16;
6233     emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
6234     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6235     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6236     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6237     gc->pc += cmdlen;
6238     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6239 }
6240
6241 #define X_GLrop_VertexAttrib2fvARB 4194
6242 void
6243 __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
6244 {
6245     __GLXcontext * const gc = __glXGetCurrentContext();
6246     const GLuint cmdlen = 16;
6247     emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
6248     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6249     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6250     gc->pc += cmdlen;
6251     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6252 }
6253
6254 #define X_GLrop_VertexAttrib2svARB 4190
6255 void
6256 __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
6257 {
6258     __GLXcontext * const gc = __glXGetCurrentContext();
6259     const GLuint cmdlen = 12;
6260     emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
6261     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6262     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6263     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6264     gc->pc += cmdlen;
6265     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6266 }
6267
6268 #define X_GLrop_VertexAttrib2svARB 4190
6269 void
6270 __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
6271 {
6272     __GLXcontext * const gc = __glXGetCurrentContext();
6273     const GLuint cmdlen = 12;
6274     emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
6275     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6276     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6277     gc->pc += cmdlen;
6278     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6279 }
6280
6281 #define X_GLrop_VertexAttrib3dvARB 4199
6282 void
6283 __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
6284 {
6285     __GLXcontext * const gc = __glXGetCurrentContext();
6286     const GLuint cmdlen = 32;
6287     emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
6288     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6289     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6290     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6291     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
6292     gc->pc += cmdlen;
6293     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6294 }
6295
6296 #define X_GLrop_VertexAttrib3dvARB 4199
6297 void
6298 __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
6299 {
6300     __GLXcontext * const gc = __glXGetCurrentContext();
6301     const GLuint cmdlen = 32;
6302     emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
6303     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
6304     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
6305     gc->pc += cmdlen;
6306     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6307 }
6308
6309 #define X_GLrop_VertexAttrib3fvARB 4195
6310 void
6311 __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
6312 {
6313     __GLXcontext * const gc = __glXGetCurrentContext();
6314     const GLuint cmdlen = 20;
6315     emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
6316     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6317     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6318     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6319     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
6320     gc->pc += cmdlen;
6321     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6322 }
6323
6324 #define X_GLrop_VertexAttrib3fvARB 4195
6325 void
6326 __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
6327 {
6328     __GLXcontext * const gc = __glXGetCurrentContext();
6329     const GLuint cmdlen = 20;
6330     emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
6331     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6332     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
6333     gc->pc += cmdlen;
6334     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6335 }
6336
6337 #define X_GLrop_VertexAttrib3svARB 4191
6338 void
6339 __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
6340 {
6341     __GLXcontext * const gc = __glXGetCurrentContext();
6342     const GLuint cmdlen = 16;
6343     emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
6344     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6345     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6346     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6347     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
6348     gc->pc += cmdlen;
6349     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6350 }
6351
6352 #define X_GLrop_VertexAttrib3svARB 4191
6353 void
6354 __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
6355 {
6356     __GLXcontext * const gc = __glXGetCurrentContext();
6357     const GLuint cmdlen = 16;
6358     emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
6359     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6360     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
6361     gc->pc += cmdlen;
6362     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6363 }
6364
6365 #define X_GLrop_VertexAttrib4dvARB 4200
6366 void
6367 __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6368 {
6369     __GLXcontext * const gc = __glXGetCurrentContext();
6370     const GLuint cmdlen = 40;
6371     emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
6372     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6373     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6374     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6375     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6376     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
6377     gc->pc += cmdlen;
6378     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6379 }
6380
6381 #define X_GLrop_VertexAttrib4dvARB 4200
6382 void
6383 __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
6384 {
6385     __GLXcontext * const gc = __glXGetCurrentContext();
6386     const GLuint cmdlen = 40;
6387     emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
6388     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
6389     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
6390     gc->pc += cmdlen;
6391     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6392 }
6393
6394 #define X_GLrop_VertexAttrib4fvARB 4196
6395 void
6396 __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6397 {
6398     __GLXcontext * const gc = __glXGetCurrentContext();
6399     const GLuint cmdlen = 24;
6400     emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
6401     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6402     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6403     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6404     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
6405     (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
6406     gc->pc += cmdlen;
6407     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6408 }
6409
6410 #define X_GLrop_VertexAttrib4fvARB 4196
6411 void
6412 __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
6413 {
6414     __GLXcontext * const gc = __glXGetCurrentContext();
6415     const GLuint cmdlen = 24;
6416     emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
6417     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6418     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6419     gc->pc += cmdlen;
6420     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6421 }
6422
6423 #define X_GLrop_VertexAttrib4svARB 4192
6424 void
6425 __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
6426 {
6427     __GLXcontext * const gc = __glXGetCurrentContext();
6428     const GLuint cmdlen = 16;
6429     emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
6430     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6431     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6432     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6433     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
6434     (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
6435     gc->pc += cmdlen;
6436     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6437 }
6438
6439 #define X_GLrop_VertexAttrib4svARB 4192
6440 void
6441 __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
6442 {
6443     __GLXcontext * const gc = __glXGetCurrentContext();
6444     const GLuint cmdlen = 16;
6445     emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
6446     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6447     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6448     gc->pc += cmdlen;
6449     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6450 }
6451
6452 #define X_GLrop_VertexAttrib4NubvARB 4201
6453 void
6454 __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
6455 {
6456     __GLXcontext * const gc = __glXGetCurrentContext();
6457     const GLuint cmdlen = 12;
6458     emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
6459     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6460     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
6461     (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
6462     (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
6463     (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
6464     gc->pc += cmdlen;
6465     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6466 }
6467
6468 #define X_GLrop_VertexAttrib4NubvARB 4201
6469 void
6470 __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
6471 {
6472     __GLXcontext * const gc = __glXGetCurrentContext();
6473     const GLuint cmdlen = 12;
6474     emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
6475     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6476     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6477     gc->pc += cmdlen;
6478     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6479 }
6480
6481 #define X_GLrop_VertexAttribs1dvNV 4210
6482 void
6483 __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
6484 {
6485     __GLXcontext * const gc = __glXGetCurrentContext();
6486     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
6487     if (__builtin_expect(n >= 0, 1)) {
6488         emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
6489         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6490         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6491         (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
6492         gc->pc += cmdlen;
6493         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6494     }
6495 }
6496
6497 #define X_GLrop_VertexAttribs1fvNV 4206
6498 void
6499 __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
6500 {
6501     __GLXcontext * const gc = __glXGetCurrentContext();
6502     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
6503     if (__builtin_expect(n >= 0, 1)) {
6504         emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
6505         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6506         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6507         (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
6508         gc->pc += cmdlen;
6509         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6510     }
6511 }
6512
6513 #define X_GLrop_VertexAttribs1svNV 4202
6514 void
6515 __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
6516 {
6517     __GLXcontext * const gc = __glXGetCurrentContext();
6518     const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
6519     if (__builtin_expect(n >= 0, 1)) {
6520         emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
6521         (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6522         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6523         (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
6524         gc->pc += cmdlen;
6525         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6526     }
6527 }
6528
6529 #define X_GLrop_VertexAttribs2dvNV 4211
6530 void
6531 __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
6532 {
6533     __GLXcontext * const gc = __glXGetCurrentContext();
6534     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
6535     emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, 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 * 8));
6539     gc->pc += cmdlen;
6540     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6541 }
6542
6543 #define X_GLrop_VertexAttribs2fvNV 4207
6544 void
6545 __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
6546 {
6547     __GLXcontext * const gc = __glXGetCurrentContext();
6548     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
6549     emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
6550     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6551     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6552     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
6553     gc->pc += cmdlen;
6554     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6555 }
6556
6557 #define X_GLrop_VertexAttribs2svNV 4203
6558 void
6559 __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
6560 {
6561     __GLXcontext * const gc = __glXGetCurrentContext();
6562     const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
6563     emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
6564     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6565     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6566     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
6567     gc->pc += cmdlen;
6568     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6569 }
6570
6571 #define X_GLrop_VertexAttribs3dvNV 4212
6572 void
6573 __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
6574 {
6575     __GLXcontext * const gc = __glXGetCurrentContext();
6576     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
6577     emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
6578     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6579     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6580     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
6581     gc->pc += cmdlen;
6582     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6583 }
6584
6585 #define X_GLrop_VertexAttribs3fvNV 4208
6586 void
6587 __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
6588 {
6589     __GLXcontext * const gc = __glXGetCurrentContext();
6590     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
6591     emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
6592     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6593     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6594     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
6595     gc->pc += cmdlen;
6596     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6597 }
6598
6599 #define X_GLrop_VertexAttribs3svNV 4204
6600 void
6601 __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
6602 {
6603     __GLXcontext * const gc = __glXGetCurrentContext();
6604     const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
6605     emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
6606     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6607     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6608     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
6609     gc->pc += cmdlen;
6610     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6611 }
6612
6613 #define X_GLrop_VertexAttribs4dvNV 4213
6614 void
6615 __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
6616 {
6617     __GLXcontext * const gc = __glXGetCurrentContext();
6618     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
6619     emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
6620     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6621     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6622     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
6623     gc->pc += cmdlen;
6624     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6625 }
6626
6627 #define X_GLrop_VertexAttribs4fvNV 4209
6628 void
6629 __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
6630 {
6631     __GLXcontext * const gc = __glXGetCurrentContext();
6632     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
6633     emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
6634     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6635     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6636     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
6637     gc->pc += cmdlen;
6638     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6639 }
6640
6641 #define X_GLrop_VertexAttribs4svNV 4205
6642 void
6643 __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
6644 {
6645     __GLXcontext * const gc = __glXGetCurrentContext();
6646     const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
6647     emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, 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 * 2));
6651     gc->pc += cmdlen;
6652     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6653 }
6654
6655 #define X_GLrop_VertexAttribs4ubvNV 4214
6656 void
6657 __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
6658 {
6659     __GLXcontext * const gc = __glXGetCurrentContext();
6660     const GLuint cmdlen = 12 + __GLX_PAD((n * 1));
6661     emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
6662     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6663     (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
6664     (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 1));
6665     gc->pc += cmdlen;
6666     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6667 }
6668
6669 #define X_GLrop_PointParameteriNV 4221
6670 void
6671 __indirect_glPointParameteriNV(GLenum pname, GLint params)
6672 {
6673     __GLXcontext * const gc = __glXGetCurrentContext();
6674     const GLuint cmdlen = 12;
6675     emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
6676     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
6677     (void) memcpy((void *)(gc->pc + 8), (void *)(&params), 4);
6678     gc->pc += cmdlen;
6679     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6680 }
6681
6682 #define X_GLrop_PointParameterivNV 4222
6683 void
6684 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
6685 {
6686     __GLXcontext * const gc = __glXGetCurrentContext();
6687     const GLuint compsize = __glPointParameterivNV_size(pname);
6688     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
6689     emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
6690     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
6691     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
6692     gc->pc += cmdlen;
6693     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6694 }
6695
6696 #define X_GLrop_ActiveStencilFaceEXT 4220
6697 void
6698 __indirect_glActiveStencilFaceEXT(GLenum face)
6699 {
6700     __GLXcontext * const gc = __glXGetCurrentContext();
6701     const GLuint cmdlen = 8;
6702     emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
6703     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
6704     gc->pc += cmdlen;
6705     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6706 }
6707
6708 #define X_GLrop_VertexAttrib4ivARB 4231
6709 void
6710 __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
6711 {
6712     __GLXcontext * const gc = __glXGetCurrentContext();
6713     const GLuint cmdlen = 24;
6714     emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
6715     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6716     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6717     gc->pc += cmdlen;
6718     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6719 }
6720
6721 #define X_GLrop_VertexAttrib4ubvARB 4232
6722 void
6723 __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
6724 {
6725     __GLXcontext * const gc = __glXGetCurrentContext();
6726     const GLuint cmdlen = 12;
6727     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
6728     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6729     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6730     gc->pc += cmdlen;
6731     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6732 }
6733
6734 #define X_GLrop_VertexAttrib4usvARB 4233
6735 void
6736 __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
6737 {
6738     __GLXcontext * const gc = __glXGetCurrentContext();
6739     const GLuint cmdlen = 16;
6740     emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
6741     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6742     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6743     gc->pc += cmdlen;
6744     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6745 }
6746
6747 #define X_GLrop_VertexAttrib4uivARB 4234
6748 void
6749 __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
6750 {
6751     __GLXcontext * const gc = __glXGetCurrentContext();
6752     const GLuint cmdlen = 24;
6753     emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
6754     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6755     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6756     gc->pc += cmdlen;
6757     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6758 }
6759
6760 #define X_GLrop_VertexAttrib4NbvARB 4235
6761 void
6762 __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
6763 {
6764     __GLXcontext * const gc = __glXGetCurrentContext();
6765     const GLuint cmdlen = 12;
6766     emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
6767     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6768     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6769     gc->pc += cmdlen;
6770     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6771 }
6772
6773 #define X_GLrop_VertexAttrib4NsvARB 4236
6774 void
6775 __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
6776 {
6777     __GLXcontext * const gc = __glXGetCurrentContext();
6778     const GLuint cmdlen = 16;
6779     emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
6780     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6781     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6782     gc->pc += cmdlen;
6783     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6784 }
6785
6786 #define X_GLrop_VertexAttrib4NivARB 4237
6787 void
6788 __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
6789 {
6790     __GLXcontext * const gc = __glXGetCurrentContext();
6791     const GLuint cmdlen = 24;
6792     emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
6793     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6794     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6795     gc->pc += cmdlen;
6796     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6797 }
6798
6799 #define X_GLrop_VertexAttrib4NusvARB 4238
6800 void
6801 __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
6802 {
6803     __GLXcontext * const gc = __glXGetCurrentContext();
6804     const GLuint cmdlen = 16;
6805     emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
6806     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6807     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6808     gc->pc += cmdlen;
6809     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6810 }
6811
6812 #define X_GLrop_VertexAttrib4NuivARB 4239
6813 void
6814 __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
6815 {
6816     __GLXcontext * const gc = __glXGetCurrentContext();
6817     const GLuint cmdlen = 24;
6818     emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
6819     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6820     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6821     gc->pc += cmdlen;
6822     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6823 }
6824
6825 #define X_GLrop_ProgramStringARB 4217
6826 void
6827 __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
6828 {
6829     __GLXcontext * const gc = __glXGetCurrentContext();
6830     const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
6831     if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
6832         if (cmdlen <= gc->maxSmallRenderCommandSize) {
6833             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
6834                 (void) __glXFlushRenderBuffer(gc, gc->pc);
6835             }
6836             emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
6837             (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6838             (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
6839             (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
6840             (void) memcpy((void *)(gc->pc + 16), (void *)(string), (len * 1));
6841             gc->pc += cmdlen;
6842             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6843         }
6844         else {
6845             const GLint op = X_GLrop_ProgramStringARB;
6846             const GLuint cmdlenLarge = cmdlen + 4;
6847             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
6848             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
6849             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
6850             (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
6851             (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
6852             (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
6853             __glXSendLargeCommand(gc, pc, 20, string, (len * 1));
6854         }
6855     }
6856 }
6857
6858 #define X_GLrop_ProgramEnvParameter4dvARB 4185
6859 void
6860 __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6861 {
6862     __GLXcontext * const gc = __glXGetCurrentContext();
6863     const GLuint cmdlen = 44;
6864     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
6865     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6866     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6867     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6868     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6869     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6870     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6871     gc->pc += cmdlen;
6872     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6873 }
6874
6875 #define X_GLrop_ProgramEnvParameter4dvARB 4185
6876 void
6877 __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
6878 {
6879     __GLXcontext * const gc = __glXGetCurrentContext();
6880     const GLuint cmdlen = 44;
6881     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
6882     (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
6883     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6884     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6885     gc->pc += cmdlen;
6886     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6887 }
6888
6889 #define X_GLrop_ProgramEnvParameter4fvARB 4184
6890 void
6891 __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6892 {
6893     __GLXcontext * const gc = __glXGetCurrentContext();
6894     const GLuint cmdlen = 28;
6895     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
6896     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6897     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6898     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6899     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6900     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6901     (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6902     gc->pc += cmdlen;
6903     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6904 }
6905
6906 #define X_GLrop_ProgramEnvParameter4fvARB 4184
6907 void
6908 __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
6909 {
6910     __GLXcontext * const gc = __glXGetCurrentContext();
6911     const GLuint cmdlen = 28;
6912     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
6913     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6914     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6915     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6916     gc->pc += cmdlen;
6917     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6918 }
6919
6920 #define X_GLrop_ProgramLocalParameter4dvARB 4216
6921 void
6922 __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6923 {
6924     __GLXcontext * const gc = __glXGetCurrentContext();
6925     const GLuint cmdlen = 44;
6926     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
6927     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
6928     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
6929     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
6930     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
6931     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6932     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6933     gc->pc += cmdlen;
6934     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6935 }
6936
6937 #define X_GLrop_ProgramLocalParameter4dvARB 4216
6938 void
6939 __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
6940 {
6941     __GLXcontext * const gc = __glXGetCurrentContext();
6942     const GLuint cmdlen = 44;
6943     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
6944     (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
6945     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
6946     (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
6947     gc->pc += cmdlen;
6948     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6949 }
6950
6951 #define X_GLrop_ProgramLocalParameter4fvARB 4215
6952 void
6953 __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6954 {
6955     __GLXcontext * const gc = __glXGetCurrentContext();
6956     const GLuint cmdlen = 28;
6957     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
6958     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6959     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6960     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6961     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6962     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6963     (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6964     gc->pc += cmdlen;
6965     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6966 }
6967
6968 #define X_GLrop_ProgramLocalParameter4fvARB 4215
6969 void
6970 __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
6971 {
6972     __GLXcontext * const gc = __glXGetCurrentContext();
6973     const GLuint cmdlen = 28;
6974     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
6975     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6976     (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6977     (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6978     gc->pc += cmdlen;
6979     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6980 }
6981
6982 #define X_GLvop_GetProgramivARB 1307
6983 void
6984 __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
6985 {
6986     __GLXcontext * const gc = __glXGetCurrentContext();
6987     Display * const dpy = gc->currentDpy;
6988     const GLuint cmdlen = 8;
6989     if (__builtin_expect(dpy != NULL, 1)) {
6990         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
6991         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
6992         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
6993         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6994         UnlockDisplay(dpy); SyncHandle();
6995     }
6996     return;
6997 }
6998
6999 #define X_GLvop_GetProgramStringARB 1308
7000 void
7001 __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
7002 {
7003     __GLXcontext * const gc = __glXGetCurrentContext();
7004     Display * const dpy = gc->currentDpy;
7005     const GLuint cmdlen = 8;
7006     if (__builtin_expect(dpy != NULL, 1)) {
7007         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
7008         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7009         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7010         (void) __glXReadReply(dpy, 0, string, GL_TRUE);
7011         UnlockDisplay(dpy); SyncHandle();
7012     }
7013     return;
7014 }
7015
7016 #define X_GLrop_ProgramNamedParameter4fvNV 4218
7017 void
7018 __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7019 {
7020     __GLXcontext * const gc = __glXGetCurrentContext();
7021     const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
7022     if (__builtin_expect(len >= 0, 1)) {
7023         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
7024         (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
7025         (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
7026         (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
7027         (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
7028         (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
7029         (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
7030         (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
7031         gc->pc += cmdlen;
7032         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7033     }
7034 }
7035
7036 #define X_GLrop_ProgramNamedParameter4dvNV 4219
7037 void
7038 __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7039 {
7040     __GLXcontext * const gc = __glXGetCurrentContext();
7041     const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
7042     if (__builtin_expect(len >= 0, 1)) {
7043         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
7044         (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7045         (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7046         (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
7047         (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
7048         (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
7049         (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
7050         (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
7051         gc->pc += cmdlen;
7052         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7053     }
7054 }
7055
7056 #define X_GLrop_ProgramNamedParameter4fvNV 4218
7057 void
7058 __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
7059 {
7060     __GLXcontext * const gc = __glXGetCurrentContext();
7061     const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
7062     if (__builtin_expect(len >= 0, 1)) {
7063         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
7064         (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
7065         (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
7066         (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
7067         (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
7068         gc->pc += cmdlen;
7069         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7070     }
7071 }
7072
7073 #define X_GLrop_ProgramNamedParameter4dvNV 4219
7074 void
7075 __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
7076 {
7077     __GLXcontext * const gc = __glXGetCurrentContext();
7078     const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
7079     if (__builtin_expect(len >= 0, 1)) {
7080         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
7081         (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
7082         (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
7083         (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
7084         (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
7085         gc->pc += cmdlen;
7086         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7087     }
7088 }
7089
7090 #define X_GLvop_GetProgramNamedParameterfvNV 1310
7091 void
7092 __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
7093 {
7094     __GLXcontext * const gc = __glXGetCurrentContext();
7095     Display * const dpy = gc->currentDpy;
7096     const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
7097     if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
7098         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
7099         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7100         (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
7101         (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
7102         (void) __glXReadReply(dpy, 4, params, GL_TRUE);
7103         UnlockDisplay(dpy); SyncHandle();
7104     }
7105     return;
7106 }
7107
7108 #define X_GLvop_GetProgramNamedParameterdvNV 1311
7109 void
7110 __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
7111 {
7112     __GLXcontext * const gc = __glXGetCurrentContext();
7113     Display * const dpy = gc->currentDpy;
7114     const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
7115     if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
7116         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
7117         (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7118         (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
7119         (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
7120         (void) __glXReadReply(dpy, 8, params, GL_TRUE);
7121         UnlockDisplay(dpy); SyncHandle();
7122     }
7123     return;
7124 }
7125
7126 #define X_GLvop_GetVertexAttribdvNV 1301
7127 void
7128 __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
7129 {
7130     __GLXcontext * const gc = __glXGetCurrentContext();
7131     Display * const dpy = gc->currentDpy;
7132     const GLuint cmdlen = 8;
7133     if (__builtin_expect(dpy != NULL, 1)) {
7134         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
7135         (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7136         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7137         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
7138         UnlockDisplay(dpy); SyncHandle();
7139     }
7140     return;
7141 }
7142
7143 #define X_GLvop_GetVertexAttribfvNV 1302
7144 void
7145 __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
7146 {
7147     __GLXcontext * const gc = __glXGetCurrentContext();
7148     Display * const dpy = gc->currentDpy;
7149     const GLuint cmdlen = 8;
7150     if (__builtin_expect(dpy != NULL, 1)) {
7151         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
7152         (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7153         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7154         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7155         UnlockDisplay(dpy); SyncHandle();
7156     }
7157     return;
7158 }
7159
7160 #define X_GLvop_GetVertexAttribivNV 1303
7161 void
7162 __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
7163 {
7164     __GLXcontext * const gc = __glXGetCurrentContext();
7165     Display * const dpy = gc->currentDpy;
7166     const GLuint cmdlen = 8;
7167     if (__builtin_expect(dpy != NULL, 1)) {
7168         GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
7169         (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7170         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7171         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7172         UnlockDisplay(dpy); SyncHandle();
7173     }
7174     return;
7175 }
7176
7177 #define X_GLrop_VertexAttrib1dvNV 4197
7178 void
7179 __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
7180 {
7181     __GLXcontext * const gc = __glXGetCurrentContext();
7182     const GLuint cmdlen = 16;
7183     emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
7184     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7185     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
7186     gc->pc += cmdlen;
7187     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7188 }
7189
7190 #define X_GLrop_VertexAttrib1dvNV 4197
7191 void
7192 __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
7193 {
7194     __GLXcontext * const gc = __glXGetCurrentContext();
7195     const GLuint cmdlen = 16;
7196     emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
7197     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
7198     (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
7199     gc->pc += cmdlen;
7200     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7201 }
7202
7203 #define X_GLrop_VertexAttrib1fvNV 4193
7204 void
7205 __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
7206 {
7207     __GLXcontext * const gc = __glXGetCurrentContext();
7208     const GLuint cmdlen = 12;
7209     emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
7210     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7211     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7212     gc->pc += cmdlen;
7213     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7214 }
7215
7216 #define X_GLrop_VertexAttrib1fvNV 4193
7217 void
7218 __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
7219 {
7220     __GLXcontext * const gc = __glXGetCurrentContext();
7221     const GLuint cmdlen = 12;
7222     emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
7223     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7224     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7225     gc->pc += cmdlen;
7226     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7227 }
7228
7229 #define X_GLrop_VertexAttrib1svNV 4189
7230 void
7231 __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
7232 {
7233     __GLXcontext * const gc = __glXGetCurrentContext();
7234     const GLuint cmdlen = 12;
7235     emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
7236     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7237     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7238     gc->pc += cmdlen;
7239     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7240 }
7241
7242 #define X_GLrop_VertexAttrib1svNV 4189
7243 void
7244 __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
7245 {
7246     __GLXcontext * const gc = __glXGetCurrentContext();
7247     const GLuint cmdlen = 12;
7248     emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
7249     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7250     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
7251     gc->pc += cmdlen;
7252     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7253 }
7254
7255 #define X_GLrop_VertexAttrib2dvNV 4198
7256 void
7257 __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
7258 {
7259     __GLXcontext * const gc = __glXGetCurrentContext();
7260     const GLuint cmdlen = 24;
7261     emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
7262     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7263     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7264     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
7265     gc->pc += cmdlen;
7266     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7267 }
7268
7269 #define X_GLrop_VertexAttrib2dvNV 4198
7270 void
7271 __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
7272 {
7273     __GLXcontext * const gc = __glXGetCurrentContext();
7274     const GLuint cmdlen = 24;
7275     emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
7276     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
7277     (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
7278     gc->pc += cmdlen;
7279     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7280 }
7281
7282 #define X_GLrop_VertexAttrib2fvNV 4194
7283 void
7284 __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
7285 {
7286     __GLXcontext * const gc = __glXGetCurrentContext();
7287     const GLuint cmdlen = 16;
7288     emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
7289     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7290     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7291     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7292     gc->pc += cmdlen;
7293     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7294 }
7295
7296 #define X_GLrop_VertexAttrib2fvNV 4194
7297 void
7298 __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
7299 {
7300     __GLXcontext * const gc = __glXGetCurrentContext();
7301     const GLuint cmdlen = 16;
7302     emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
7303     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7304     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7305     gc->pc += cmdlen;
7306     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7307 }
7308
7309 #define X_GLrop_VertexAttrib2svNV 4190
7310 void
7311 __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
7312 {
7313     __GLXcontext * const gc = __glXGetCurrentContext();
7314     const GLuint cmdlen = 12;
7315     emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
7316     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7317     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7318     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7319     gc->pc += cmdlen;
7320     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7321 }
7322
7323 #define X_GLrop_VertexAttrib2svNV 4190
7324 void
7325 __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
7326 {
7327     __GLXcontext * const gc = __glXGetCurrentContext();
7328     const GLuint cmdlen = 12;
7329     emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
7330     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7331     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7332     gc->pc += cmdlen;
7333     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7334 }
7335
7336 #define X_GLrop_VertexAttrib3dvNV 4199
7337 void
7338 __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
7339 {
7340     __GLXcontext * const gc = __glXGetCurrentContext();
7341     const GLuint cmdlen = 32;
7342     emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
7343     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7344     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7345     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
7346     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
7347     gc->pc += cmdlen;
7348     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7349 }
7350
7351 #define X_GLrop_VertexAttrib3dvNV 4199
7352 void
7353 __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
7354 {
7355     __GLXcontext * const gc = __glXGetCurrentContext();
7356     const GLuint cmdlen = 32;
7357     emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
7358     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
7359     (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
7360     gc->pc += cmdlen;
7361     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7362 }
7363
7364 #define X_GLrop_VertexAttrib3fvNV 4195
7365 void
7366 __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
7367 {
7368     __GLXcontext * const gc = __glXGetCurrentContext();
7369     const GLuint cmdlen = 20;
7370     emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
7371     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7372     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7373     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7374     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 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_VertexAttrib3fvNV 4195
7380 void
7381 __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
7382 {
7383     __GLXcontext * const gc = __glXGetCurrentContext();
7384     const GLuint cmdlen = 20;
7385     emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
7386     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7387     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
7388     gc->pc += cmdlen;
7389     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7390 }
7391
7392 #define X_GLrop_VertexAttrib3svNV 4191
7393 void
7394 __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
7395 {
7396     __GLXcontext * const gc = __glXGetCurrentContext();
7397     const GLuint cmdlen = 16;
7398     emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
7399     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7400     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7401     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7402     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
7403     gc->pc += cmdlen;
7404     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7405 }
7406
7407 #define X_GLrop_VertexAttrib3svNV 4191
7408 void
7409 __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
7410 {
7411     __GLXcontext * const gc = __glXGetCurrentContext();
7412     const GLuint cmdlen = 16;
7413     emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
7414     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7415     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
7416     gc->pc += cmdlen;
7417     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7418 }
7419
7420 #define X_GLrop_VertexAttrib4dvNV 4200
7421 void
7422 __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7423 {
7424     __GLXcontext * const gc = __glXGetCurrentContext();
7425     const GLuint cmdlen = 40;
7426     emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
7427     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
7428     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
7429     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
7430     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
7431     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
7432     gc->pc += cmdlen;
7433     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7434 }
7435
7436 #define X_GLrop_VertexAttrib4dvNV 4200
7437 void
7438 __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
7439 {
7440     __GLXcontext * const gc = __glXGetCurrentContext();
7441     const GLuint cmdlen = 40;
7442     emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
7443     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
7444     (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
7445     gc->pc += cmdlen;
7446     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7447 }
7448
7449 #define X_GLrop_VertexAttrib4fvNV 4196
7450 void
7451 __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7452 {
7453     __GLXcontext * const gc = __glXGetCurrentContext();
7454     const GLuint cmdlen = 24;
7455     emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
7456     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7457     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7458     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7459     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
7460     (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
7461     gc->pc += cmdlen;
7462     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7463 }
7464
7465 #define X_GLrop_VertexAttrib4fvNV 4196
7466 void
7467 __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
7468 {
7469     __GLXcontext * const gc = __glXGetCurrentContext();
7470     const GLuint cmdlen = 24;
7471     emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
7472     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7473     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
7474     gc->pc += cmdlen;
7475     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7476 }
7477
7478 #define X_GLrop_VertexAttrib4svNV 4192
7479 void
7480 __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
7481 {
7482     __GLXcontext * const gc = __glXGetCurrentContext();
7483     const GLuint cmdlen = 16;
7484     emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
7485     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7486     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7487     (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7488     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
7489     (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
7490     gc->pc += cmdlen;
7491     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7492 }
7493
7494 #define X_GLrop_VertexAttrib4svNV 4192
7495 void
7496 __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
7497 {
7498     __GLXcontext * const gc = __glXGetCurrentContext();
7499     const GLuint cmdlen = 16;
7500     emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
7501     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7502     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7503     gc->pc += cmdlen;
7504     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7505 }
7506
7507 #define X_GLrop_VertexAttrib4ubvNV 4201
7508 void
7509 __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
7510 {
7511     __GLXcontext * const gc = __glXGetCurrentContext();
7512     const GLuint cmdlen = 12;
7513     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
7514     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7515     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
7516     (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
7517     (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
7518     (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
7519     gc->pc += cmdlen;
7520     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7521 }
7522
7523 #define X_GLrop_VertexAttrib4ubvNV 4201
7524 void
7525 __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
7526 {
7527     __GLXcontext * const gc = __glXGetCurrentContext();
7528     const GLuint cmdlen = 12;
7529     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
7530     (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7531     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7532     gc->pc += cmdlen;
7533     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7534 }
7535