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