src/glx/x11/indirect_dispatch.c

   1 /* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
   2
   3 /*
   4  * (C) Copyright IBM Corporation 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 #include <X11/Xmd.h>
  29 #include <GL/gl.h>
  30 #include <GL/glxproto.h>
  31 #include <inttypes.h>
  32 #include "indirect_size.h"
  33 #include "indirect_size_get.h"
  34 #include "indirect_dispatch.h"
  35 #include "glxserver.h"
  36 #include "glxbyteorder.h"
  37 #include "indirect_util.h"
  38 #include "singlesize.h"
  39 #include "glapitable.h"
  40 #include "glapi.h"
  41 #include "glthread.h"
  42 #include "dispatch.h"
  43
  44 #define __GLX_PAD(x)  (((x) + 3) & ~3)
  45
  46 typedef struct {
  47     __GLX_PIXEL_3D_HDR;
  48 } __GLXpixel3DHeader;
  49
  50 extern GLboolean __glXErrorOccured( void );
  51 extern void __glXClearErrorOccured( void );
  52
  53 static const unsigned dummy_answer[2] = {0, 0};
  54
  55 int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc)
  56 {
  57     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
  58     int error;
  59     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
  60
  61     pc += __GLX_SINGLE_HDR_SIZE;
  62     if ( cx != NULL ) {
  63         CALL_NewList( GET_DISPATCH(), (
  64             *(GLuint   *)(pc +  0),
  65             *(GLenum   *)(pc +  4)
  66         ) );
  67         error = Success;
  68     }
  69
  70     return error;
  71 }
  72
  73 int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc)
  74 {
  75     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
  76     int error;
  77     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
  78
  79     pc += __GLX_SINGLE_HDR_SIZE;
  80     if ( cx != NULL ) {
  81         CALL_EndList( GET_DISPATCH(), () );
  82         error = Success;
  83     }
  84
  85     return error;
  86 }
  87
  88 void __glXDisp_CallList(GLbyte * pc)
  89 {
  90     CALL_CallList( GET_DISPATCH(), (
  91         *(GLuint   *)(pc +  0)
  92     ) );
  93 }
  94
  95 void __glXDisp_CallLists(GLbyte * pc)
  96 {
  97     const GLsizei n = *(GLsizei  *)(pc +  0);
  98     const GLenum type = *(GLenum   *)(pc +  4);
  99     const GLvoid * lists =  (const GLvoid *)(pc +  8);
 100
 101     lists = (const GLvoid *) (pc + 8);
 102
 103     CALL_CallLists( GET_DISPATCH(), (
 104         n,
 105         type,
 106         lists
 107     ) );
 108 }
 109
 110 int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc)
 111 {
 112     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
 113     int error;
 114     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
 115
 116     pc += __GLX_SINGLE_HDR_SIZE;
 117     if ( cx != NULL ) {
 118         CALL_DeleteLists( GET_DISPATCH(), (
 119             *(GLuint   *)(pc +  0),
 120             *(GLsizei  *)(pc +  4)
 121         ) );
 122         error = Success;
 123     }
 124
 125     return error;
 126 }
 127
 128 int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc)
 129 {
 130     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
 131     int error;
 132     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
 133
 134     pc += __GLX_SINGLE_HDR_SIZE;
 135     if ( cx != NULL ) {
 136         GLuint retval;
 137         retval = CALL_GenLists( GET_DISPATCH(), (
 138             *(GLsizei  *)(pc +  0)
 139         ) );
 140         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
 141         error = Success;
 142     }
 143
 144     return error;
 145 }
 146
 147 void __glXDisp_ListBase(GLbyte * pc)
 148 {
 149     CALL_ListBase( GET_DISPATCH(), (
 150         *(GLuint   *)(pc +  0)
 151     ) );
 152 }
 153
 154 void __glXDisp_Begin(GLbyte * pc)
 155 {
 156     CALL_Begin( GET_DISPATCH(), (
 157         *(GLenum   *)(pc +  0)
 158     ) );
 159 }
 160
 161 void __glXDisp_Bitmap(GLbyte * pc)
 162 {
 163     const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
 164     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 165
 166     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
 167     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
 168     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
 169     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
 170     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
 171
 172     CALL_Bitmap( GET_DISPATCH(), (
 173         *(GLsizei  *)(pc + 20),
 174         *(GLsizei  *)(pc + 24),
 175         *(GLfloat  *)(pc + 28),
 176         *(GLfloat  *)(pc + 32),
 177         *(GLfloat  *)(pc + 36),
 178         *(GLfloat  *)(pc + 40),
 179         bitmap
 180     ) );
 181 }
 182
 183 void __glXDisp_Color3bv(GLbyte * pc)
 184 {
 185     CALL_Color3bv( GET_DISPATCH(), (
 186          (const GLbyte *)(pc +  0)
 187     ) );
 188 }
 189
 190 void __glXDisp_Color3dv(GLbyte * pc)
 191 {
 192 #ifdef __GLX_ALIGN64
 193     if ((unsigned long)(pc) & 7) {
 194         (void) memmove(pc-4, pc, 24);
 195         pc -= 4;
 196     }
 197 #endif
 198
 199     CALL_Color3dv( GET_DISPATCH(), (
 200          (const GLdouble *)(pc +  0)
 201     ) );
 202 }
 203
 204 void __glXDisp_Color3fv(GLbyte * pc)
 205 {
 206     CALL_Color3fv( GET_DISPATCH(), (
 207          (const GLfloat *)(pc +  0)
 208     ) );
 209 }
 210
 211 void __glXDisp_Color3iv(GLbyte * pc)
 212 {
 213     CALL_Color3iv( GET_DISPATCH(), (
 214          (const GLint *)(pc +  0)
 215     ) );
 216 }
 217
 218 void __glXDisp_Color3sv(GLbyte * pc)
 219 {
 220     CALL_Color3sv( GET_DISPATCH(), (
 221          (const GLshort *)(pc +  0)
 222     ) );
 223 }
 224
 225 void __glXDisp_Color3ubv(GLbyte * pc)
 226 {
 227     CALL_Color3ubv( GET_DISPATCH(), (
 228          (const GLubyte *)(pc +  0)
 229     ) );
 230 }
 231
 232 void __glXDisp_Color3uiv(GLbyte * pc)
 233 {
 234     CALL_Color3uiv( GET_DISPATCH(), (
 235          (const GLuint *)(pc +  0)
 236     ) );
 237 }
 238
 239 void __glXDisp_Color3usv(GLbyte * pc)
 240 {
 241     CALL_Color3usv( GET_DISPATCH(), (
 242          (const GLushort *)(pc +  0)
 243     ) );
 244 }
 245
 246 void __glXDisp_Color4bv(GLbyte * pc)
 247 {
 248     CALL_Color4bv( GET_DISPATCH(), (
 249          (const GLbyte *)(pc +  0)
 250     ) );
 251 }
 252
 253 void __glXDisp_Color4dv(GLbyte * pc)
 254 {
 255 #ifdef __GLX_ALIGN64
 256     if ((unsigned long)(pc) & 7) {
 257         (void) memmove(pc-4, pc, 32);
 258         pc -= 4;
 259     }
 260 #endif
 261
 262     CALL_Color4dv( GET_DISPATCH(), (
 263          (const GLdouble *)(pc +  0)
 264     ) );
 265 }
 266
 267 void __glXDisp_Color4fv(GLbyte * pc)
 268 {
 269     CALL_Color4fv( GET_DISPATCH(), (
 270          (const GLfloat *)(pc +  0)
 271     ) );
 272 }
 273
 274 void __glXDisp_Color4iv(GLbyte * pc)
 275 {
 276     CALL_Color4iv( GET_DISPATCH(), (
 277          (const GLint *)(pc +  0)
 278     ) );
 279 }
 280
 281 void __glXDisp_Color4sv(GLbyte * pc)
 282 {
 283     CALL_Color4sv( GET_DISPATCH(), (
 284          (const GLshort *)(pc +  0)
 285     ) );
 286 }
 287
 288 void __glXDisp_Color4ubv(GLbyte * pc)
 289 {
 290     CALL_Color4ubv( GET_DISPATCH(), (
 291          (const GLubyte *)(pc +  0)
 292     ) );
 293 }
 294
 295 void __glXDisp_Color4uiv(GLbyte * pc)
 296 {
 297     CALL_Color4uiv( GET_DISPATCH(), (
 298          (const GLuint *)(pc +  0)
 299     ) );
 300 }
 301
 302 void __glXDisp_Color4usv(GLbyte * pc)
 303 {
 304     CALL_Color4usv( GET_DISPATCH(), (
 305          (const GLushort *)(pc +  0)
 306     ) );
 307 }
 308
 309 void __glXDisp_EdgeFlagv(GLbyte * pc)
 310 {
 311     CALL_EdgeFlagv( GET_DISPATCH(), (
 312          (const GLboolean *)(pc +  0)
 313     ) );
 314 }
 315
 316 void __glXDisp_End(GLbyte * pc)
 317 {
 318     CALL_End( GET_DISPATCH(), () );
 319 }
 320
 321 void __glXDisp_Indexdv(GLbyte * pc)
 322 {
 323 #ifdef __GLX_ALIGN64
 324     if ((unsigned long)(pc) & 7) {
 325         (void) memmove(pc-4, pc, 8);
 326         pc -= 4;
 327     }
 328 #endif
 329
 330     CALL_Indexdv( GET_DISPATCH(), (
 331          (const GLdouble *)(pc +  0)
 332     ) );
 333 }
 334
 335 void __glXDisp_Indexfv(GLbyte * pc)
 336 {
 337     CALL_Indexfv( GET_DISPATCH(), (
 338          (const GLfloat *)(pc +  0)
 339     ) );
 340 }
 341
 342 void __glXDisp_Indexiv(GLbyte * pc)
 343 {
 344     CALL_Indexiv( GET_DISPATCH(), (
 345          (const GLint *)(pc +  0)
 346     ) );
 347 }
 348
 349 void __glXDisp_Indexsv(GLbyte * pc)
 350 {
 351     CALL_Indexsv( GET_DISPATCH(), (
 352          (const GLshort *)(pc +  0)
 353     ) );
 354 }
 355
 356 void __glXDisp_Normal3bv(GLbyte * pc)
 357 {
 358     CALL_Normal3bv( GET_DISPATCH(), (
 359          (const GLbyte *)(pc +  0)
 360     ) );
 361 }
 362
 363 void __glXDisp_Normal3dv(GLbyte * pc)
 364 {
 365 #ifdef __GLX_ALIGN64
 366     if ((unsigned long)(pc) & 7) {
 367         (void) memmove(pc-4, pc, 24);
 368         pc -= 4;
 369     }
 370 #endif
 371
 372     CALL_Normal3dv( GET_DISPATCH(), (
 373          (const GLdouble *)(pc +  0)
 374     ) );
 375 }
 376
 377 void __glXDisp_Normal3fv(GLbyte * pc)
 378 {
 379     CALL_Normal3fv( GET_DISPATCH(), (
 380          (const GLfloat *)(pc +  0)
 381     ) );
 382 }
 383
 384 void __glXDisp_Normal3iv(GLbyte * pc)
 385 {
 386     CALL_Normal3iv( GET_DISPATCH(), (
 387          (const GLint *)(pc +  0)
 388     ) );
 389 }
 390
 391 void __glXDisp_Normal3sv(GLbyte * pc)
 392 {
 393     CALL_Normal3sv( GET_DISPATCH(), (
 394          (const GLshort *)(pc +  0)
 395     ) );
 396 }
 397
 398 void __glXDisp_RasterPos2dv(GLbyte * pc)
 399 {
 400 #ifdef __GLX_ALIGN64
 401     if ((unsigned long)(pc) & 7) {
 402         (void) memmove(pc-4, pc, 16);
 403         pc -= 4;
 404     }
 405 #endif
 406
 407     CALL_RasterPos2dv( GET_DISPATCH(), (
 408          (const GLdouble *)(pc +  0)
 409     ) );
 410 }
 411
 412 void __glXDisp_RasterPos2fv(GLbyte * pc)
 413 {
 414     CALL_RasterPos2fv( GET_DISPATCH(), (
 415          (const GLfloat *)(pc +  0)
 416     ) );
 417 }
 418
 419 void __glXDisp_RasterPos2iv(GLbyte * pc)
 420 {
 421     CALL_RasterPos2iv( GET_DISPATCH(), (
 422          (const GLint *)(pc +  0)
 423     ) );
 424 }
 425
 426 void __glXDisp_RasterPos2sv(GLbyte * pc)
 427 {
 428     CALL_RasterPos2sv( GET_DISPATCH(), (
 429          (const GLshort *)(pc +  0)
 430     ) );
 431 }
 432
 433 void __glXDisp_RasterPos3dv(GLbyte * pc)
 434 {
 435 #ifdef __GLX_ALIGN64
 436     if ((unsigned long)(pc) & 7) {
 437         (void) memmove(pc-4, pc, 24);
 438         pc -= 4;
 439     }
 440 #endif
 441
 442     CALL_RasterPos3dv( GET_DISPATCH(), (
 443          (const GLdouble *)(pc +  0)
 444     ) );
 445 }
 446
 447 void __glXDisp_RasterPos3fv(GLbyte * pc)
 448 {
 449     CALL_RasterPos3fv( GET_DISPATCH(), (
 450          (const GLfloat *)(pc +  0)
 451     ) );
 452 }
 453
 454 void __glXDisp_RasterPos3iv(GLbyte * pc)
 455 {
 456     CALL_RasterPos3iv( GET_DISPATCH(), (
 457          (const GLint *)(pc +  0)
 458     ) );
 459 }
 460
 461 void __glXDisp_RasterPos3sv(GLbyte * pc)
 462 {
 463     CALL_RasterPos3sv( GET_DISPATCH(), (
 464          (const GLshort *)(pc +  0)
 465     ) );
 466 }
 467
 468 void __glXDisp_RasterPos4dv(GLbyte * pc)
 469 {
 470 #ifdef __GLX_ALIGN64
 471     if ((unsigned long)(pc) & 7) {
 472         (void) memmove(pc-4, pc, 32);
 473         pc -= 4;
 474     }
 475 #endif
 476
 477     CALL_RasterPos4dv( GET_DISPATCH(), (
 478          (const GLdouble *)(pc +  0)
 479     ) );
 480 }
 481
 482 void __glXDisp_RasterPos4fv(GLbyte * pc)
 483 {
 484     CALL_RasterPos4fv( GET_DISPATCH(), (
 485          (const GLfloat *)(pc +  0)
 486     ) );
 487 }
 488
 489 void __glXDisp_RasterPos4iv(GLbyte * pc)
 490 {
 491     CALL_RasterPos4iv( GET_DISPATCH(), (
 492          (const GLint *)(pc +  0)
 493     ) );
 494 }
 495
 496 void __glXDisp_RasterPos4sv(GLbyte * pc)
 497 {
 498     CALL_RasterPos4sv( GET_DISPATCH(), (
 499          (const GLshort *)(pc +  0)
 500     ) );
 501 }
 502
 503 void __glXDisp_Rectdv(GLbyte * pc)
 504 {
 505 #ifdef __GLX_ALIGN64
 506     if ((unsigned long)(pc) & 7) {
 507         (void) memmove(pc-4, pc, 32);
 508         pc -= 4;
 509     }
 510 #endif
 511
 512     CALL_Rectdv( GET_DISPATCH(), (
 513          (const GLdouble *)(pc +  0),
 514          (const GLdouble *)(pc + 16)
 515     ) );
 516 }
 517
 518 void __glXDisp_Rectfv(GLbyte * pc)
 519 {
 520     CALL_Rectfv( GET_DISPATCH(), (
 521          (const GLfloat *)(pc +  0),
 522          (const GLfloat *)(pc +  8)
 523     ) );
 524 }
 525
 526 void __glXDisp_Rectiv(GLbyte * pc)
 527 {
 528     CALL_Rectiv( GET_DISPATCH(), (
 529          (const GLint *)(pc +  0),
 530          (const GLint *)(pc +  8)
 531     ) );
 532 }
 533
 534 void __glXDisp_Rectsv(GLbyte * pc)
 535 {
 536     CALL_Rectsv( GET_DISPATCH(), (
 537          (const GLshort *)(pc +  0),
 538          (const GLshort *)(pc +  4)
 539     ) );
 540 }
 541
 542 void __glXDisp_TexCoord1dv(GLbyte * pc)
 543 {
 544 #ifdef __GLX_ALIGN64
 545     if ((unsigned long)(pc) & 7) {
 546         (void) memmove(pc-4, pc, 8);
 547         pc -= 4;
 548     }
 549 #endif
 550
 551     CALL_TexCoord1dv( GET_DISPATCH(), (
 552          (const GLdouble *)(pc +  0)
 553     ) );
 554 }
 555
 556 void __glXDisp_TexCoord1fv(GLbyte * pc)
 557 {
 558     CALL_TexCoord1fv( GET_DISPATCH(), (
 559          (const GLfloat *)(pc +  0)
 560     ) );
 561 }
 562
 563 void __glXDisp_TexCoord1iv(GLbyte * pc)
 564 {
 565     CALL_TexCoord1iv( GET_DISPATCH(), (
 566          (const GLint *)(pc +  0)
 567     ) );
 568 }
 569
 570 void __glXDisp_TexCoord1sv(GLbyte * pc)
 571 {
 572     CALL_TexCoord1sv( GET_DISPATCH(), (
 573          (const GLshort *)(pc +  0)
 574     ) );
 575 }
 576
 577 void __glXDisp_TexCoord2dv(GLbyte * pc)
 578 {
 579 #ifdef __GLX_ALIGN64
 580     if ((unsigned long)(pc) & 7) {
 581         (void) memmove(pc-4, pc, 16);
 582         pc -= 4;
 583     }
 584 #endif
 585
 586     CALL_TexCoord2dv( GET_DISPATCH(), (
 587          (const GLdouble *)(pc +  0)
 588     ) );
 589 }
 590
 591 void __glXDisp_TexCoord2fv(GLbyte * pc)
 592 {
 593     CALL_TexCoord2fv( GET_DISPATCH(), (
 594          (const GLfloat *)(pc +  0)
 595     ) );
 596 }
 597
 598 void __glXDisp_TexCoord2iv(GLbyte * pc)
 599 {
 600     CALL_TexCoord2iv( GET_DISPATCH(), (
 601          (const GLint *)(pc +  0)
 602     ) );
 603 }
 604
 605 void __glXDisp_TexCoord2sv(GLbyte * pc)
 606 {
 607     CALL_TexCoord2sv( GET_DISPATCH(), (
 608          (const GLshort *)(pc +  0)
 609     ) );
 610 }
 611
 612 void __glXDisp_TexCoord3dv(GLbyte * pc)
 613 {
 614 #ifdef __GLX_ALIGN64
 615     if ((unsigned long)(pc) & 7) {
 616         (void) memmove(pc-4, pc, 24);
 617         pc -= 4;
 618     }
 619 #endif
 620
 621     CALL_TexCoord3dv( GET_DISPATCH(), (
 622          (const GLdouble *)(pc +  0)
 623     ) );
 624 }
 625
 626 void __glXDisp_TexCoord3fv(GLbyte * pc)
 627 {
 628     CALL_TexCoord3fv( GET_DISPATCH(), (
 629          (const GLfloat *)(pc +  0)
 630     ) );
 631 }
 632
 633 void __glXDisp_TexCoord3iv(GLbyte * pc)
 634 {
 635     CALL_TexCoord3iv( GET_DISPATCH(), (
 636          (const GLint *)(pc +  0)
 637     ) );
 638 }
 639
 640 void __glXDisp_TexCoord3sv(GLbyte * pc)
 641 {
 642     CALL_TexCoord3sv( GET_DISPATCH(), (
 643          (const GLshort *)(pc +  0)
 644     ) );
 645 }
 646
 647 void __glXDisp_TexCoord4dv(GLbyte * pc)
 648 {
 649 #ifdef __GLX_ALIGN64
 650     if ((unsigned long)(pc) & 7) {
 651         (void) memmove(pc-4, pc, 32);
 652         pc -= 4;
 653     }
 654 #endif
 655
 656     CALL_TexCoord4dv( GET_DISPATCH(), (
 657          (const GLdouble *)(pc +  0)
 658     ) );
 659 }
 660
 661 void __glXDisp_TexCoord4fv(GLbyte * pc)
 662 {
 663     CALL_TexCoord4fv( GET_DISPATCH(), (
 664          (const GLfloat *)(pc +  0)
 665     ) );
 666 }
 667
 668 void __glXDisp_TexCoord4iv(GLbyte * pc)
 669 {
 670     CALL_TexCoord4iv( GET_DISPATCH(), (
 671          (const GLint *)(pc +  0)
 672     ) );
 673 }
 674
 675 void __glXDisp_TexCoord4sv(GLbyte * pc)
 676 {
 677     CALL_TexCoord4sv( GET_DISPATCH(), (
 678          (const GLshort *)(pc +  0)
 679     ) );
 680 }
 681
 682 void __glXDisp_Vertex2dv(GLbyte * pc)
 683 {
 684 #ifdef __GLX_ALIGN64
 685     if ((unsigned long)(pc) & 7) {
 686         (void) memmove(pc-4, pc, 16);
 687         pc -= 4;
 688     }
 689 #endif
 690
 691     CALL_Vertex2dv( GET_DISPATCH(), (
 692          (const GLdouble *)(pc +  0)
 693     ) );
 694 }
 695
 696 void __glXDisp_Vertex2fv(GLbyte * pc)
 697 {
 698     CALL_Vertex2fv( GET_DISPATCH(), (
 699          (const GLfloat *)(pc +  0)
 700     ) );
 701 }
 702
 703 void __glXDisp_Vertex2iv(GLbyte * pc)
 704 {
 705     CALL_Vertex2iv( GET_DISPATCH(), (
 706          (const GLint *)(pc +  0)
 707     ) );
 708 }
 709
 710 void __glXDisp_Vertex2sv(GLbyte * pc)
 711 {
 712     CALL_Vertex2sv( GET_DISPATCH(), (
 713          (const GLshort *)(pc +  0)
 714     ) );
 715 }
 716
 717 void __glXDisp_Vertex3dv(GLbyte * pc)
 718 {
 719 #ifdef __GLX_ALIGN64
 720     if ((unsigned long)(pc) & 7) {
 721         (void) memmove(pc-4, pc, 24);
 722         pc -= 4;
 723     }
 724 #endif
 725
 726     CALL_Vertex3dv( GET_DISPATCH(), (
 727          (const GLdouble *)(pc +  0)
 728     ) );
 729 }
 730
 731 void __glXDisp_Vertex3fv(GLbyte * pc)
 732 {
 733     CALL_Vertex3fv( GET_DISPATCH(), (
 734          (const GLfloat *)(pc +  0)
 735     ) );
 736 }
 737
 738 void __glXDisp_Vertex3iv(GLbyte * pc)
 739 {
 740     CALL_Vertex3iv( GET_DISPATCH(), (
 741          (const GLint *)(pc +  0)
 742     ) );
 743 }
 744
 745 void __glXDisp_Vertex3sv(GLbyte * pc)
 746 {
 747     CALL_Vertex3sv( GET_DISPATCH(), (
 748          (const GLshort *)(pc +  0)
 749     ) );
 750 }
 751
 752 void __glXDisp_Vertex4dv(GLbyte * pc)
 753 {
 754 #ifdef __GLX_ALIGN64
 755     if ((unsigned long)(pc) & 7) {
 756         (void) memmove(pc-4, pc, 32);
 757         pc -= 4;
 758     }
 759 #endif
 760
 761     CALL_Vertex4dv( GET_DISPATCH(), (
 762          (const GLdouble *)(pc +  0)
 763     ) );
 764 }
 765
 766 void __glXDisp_Vertex4fv(GLbyte * pc)
 767 {
 768     CALL_Vertex4fv( GET_DISPATCH(), (
 769          (const GLfloat *)(pc +  0)
 770     ) );
 771 }
 772
 773 void __glXDisp_Vertex4iv(GLbyte * pc)
 774 {
 775     CALL_Vertex4iv( GET_DISPATCH(), (
 776          (const GLint *)(pc +  0)
 777     ) );
 778 }
 779
 780 void __glXDisp_Vertex4sv(GLbyte * pc)
 781 {
 782     CALL_Vertex4sv( GET_DISPATCH(), (
 783          (const GLshort *)(pc +  0)
 784     ) );
 785 }
 786
 787 void __glXDisp_ClipPlane(GLbyte * pc)
 788 {
 789 #ifdef __GLX_ALIGN64
 790     if ((unsigned long)(pc) & 7) {
 791         (void) memmove(pc-4, pc, 36);
 792         pc -= 4;
 793     }
 794 #endif
 795
 796     CALL_ClipPlane( GET_DISPATCH(), (
 797         *(GLenum   *)(pc + 32),
 798          (const GLdouble *)(pc +  0)
 799     ) );
 800 }
 801
 802 void __glXDisp_ColorMaterial(GLbyte * pc)
 803 {
 804     CALL_ColorMaterial( GET_DISPATCH(), (
 805         *(GLenum   *)(pc +  0),
 806         *(GLenum   *)(pc +  4)
 807     ) );
 808 }
 809
 810 void __glXDisp_CullFace(GLbyte * pc)
 811 {
 812     CALL_CullFace( GET_DISPATCH(), (
 813         *(GLenum   *)(pc +  0)
 814     ) );
 815 }
 816
 817 void __glXDisp_Fogf(GLbyte * pc)
 818 {
 819     CALL_Fogf( GET_DISPATCH(), (
 820         *(GLenum   *)(pc +  0),
 821         *(GLfloat  *)(pc +  4)
 822     ) );
 823 }
 824
 825 void __glXDisp_Fogfv(GLbyte * pc)
 826 {
 827     const GLenum pname = *(GLenum   *)(pc +  0);
 828     const GLfloat * params;
 829
 830     params = (const GLfloat *) (pc + 4);
 831
 832     CALL_Fogfv( GET_DISPATCH(), (
 833         pname,
 834         params
 835     ) );
 836 }
 837
 838 void __glXDisp_Fogi(GLbyte * pc)
 839 {
 840     CALL_Fogi( GET_DISPATCH(), (
 841         *(GLenum   *)(pc +  0),
 842         *(GLint    *)(pc +  4)
 843     ) );
 844 }
 845
 846 void __glXDisp_Fogiv(GLbyte * pc)
 847 {
 848     const GLenum pname = *(GLenum   *)(pc +  0);
 849     const GLint * params;
 850
 851     params = (const GLint *) (pc + 4);
 852
 853     CALL_Fogiv( GET_DISPATCH(), (
 854         pname,
 855         params
 856     ) );
 857 }
 858
 859 void __glXDisp_FrontFace(GLbyte * pc)
 860 {
 861     CALL_FrontFace( GET_DISPATCH(), (
 862         *(GLenum   *)(pc +  0)
 863     ) );
 864 }
 865
 866 void __glXDisp_Hint(GLbyte * pc)
 867 {
 868     CALL_Hint( GET_DISPATCH(), (
 869         *(GLenum   *)(pc +  0),
 870         *(GLenum   *)(pc +  4)
 871     ) );
 872 }
 873
 874 void __glXDisp_Lightf(GLbyte * pc)
 875 {
 876     CALL_Lightf( GET_DISPATCH(), (
 877         *(GLenum   *)(pc +  0),
 878         *(GLenum   *)(pc +  4),
 879         *(GLfloat  *)(pc +  8)
 880     ) );
 881 }
 882
 883 void __glXDisp_Lightfv(GLbyte * pc)
 884 {
 885     const GLenum pname = *(GLenum   *)(pc +  4);
 886     const GLfloat * params;
 887
 888     params = (const GLfloat *) (pc + 8);
 889
 890     CALL_Lightfv( GET_DISPATCH(), (
 891         *(GLenum   *)(pc +  0),
 892         pname,
 893         params
 894     ) );
 895 }
 896
 897 void __glXDisp_Lighti(GLbyte * pc)
 898 {
 899     CALL_Lighti( GET_DISPATCH(), (
 900         *(GLenum   *)(pc +  0),
 901         *(GLenum   *)(pc +  4),
 902         *(GLint    *)(pc +  8)
 903     ) );
 904 }
 905
 906 void __glXDisp_Lightiv(GLbyte * pc)
 907 {
 908     const GLenum pname = *(GLenum   *)(pc +  4);
 909     const GLint * params;
 910
 911     params = (const GLint *) (pc + 8);
 912
 913     CALL_Lightiv( GET_DISPATCH(), (
 914         *(GLenum   *)(pc +  0),
 915         pname,
 916         params
 917     ) );
 918 }
 919
 920 void __glXDisp_LightModelf(GLbyte * pc)
 921 {
 922     CALL_LightModelf( GET_DISPATCH(), (
 923         *(GLenum   *)(pc +  0),
 924         *(GLfloat  *)(pc +  4)
 925     ) );
 926 }
 927
 928 void __glXDisp_LightModelfv(GLbyte * pc)
 929 {
 930     const GLenum pname = *(GLenum   *)(pc +  0);
 931     const GLfloat * params;
 932
 933     params = (const GLfloat *) (pc + 4);
 934
 935     CALL_LightModelfv( GET_DISPATCH(), (
 936         pname,
 937         params
 938     ) );
 939 }
 940
 941 void __glXDisp_LightModeli(GLbyte * pc)
 942 {
 943     CALL_LightModeli( GET_DISPATCH(), (
 944         *(GLenum   *)(pc +  0),
 945         *(GLint    *)(pc +  4)
 946     ) );
 947 }
 948
 949 void __glXDisp_LightModeliv(GLbyte * pc)
 950 {
 951     const GLenum pname = *(GLenum   *)(pc +  0);
 952     const GLint * params;
 953
 954     params = (const GLint *) (pc + 4);
 955
 956     CALL_LightModeliv( GET_DISPATCH(), (
 957         pname,
 958         params
 959     ) );
 960 }
 961
 962 void __glXDisp_LineStipple(GLbyte * pc)
 963 {
 964     CALL_LineStipple( GET_DISPATCH(), (
 965         *(GLint    *)(pc +  0),
 966         *(GLushort *)(pc +  4)
 967     ) );
 968 }
 969
 970 void __glXDisp_LineWidth(GLbyte * pc)
 971 {
 972     CALL_LineWidth( GET_DISPATCH(), (
 973         *(GLfloat  *)(pc +  0)
 974     ) );
 975 }
 976
 977 void __glXDisp_Materialf(GLbyte * pc)
 978 {
 979     CALL_Materialf( GET_DISPATCH(), (
 980         *(GLenum   *)(pc +  0),
 981         *(GLenum   *)(pc +  4),
 982         *(GLfloat  *)(pc +  8)
 983     ) );
 984 }
 985
 986 void __glXDisp_Materialfv(GLbyte * pc)
 987 {
 988     const GLenum pname = *(GLenum   *)(pc +  4);
 989     const GLfloat * params;
 990
 991     params = (const GLfloat *) (pc + 8);
 992
 993     CALL_Materialfv( GET_DISPATCH(), (
 994         *(GLenum   *)(pc +  0),
 995         pname,
 996         params
 997     ) );
 998 }
 999
1000 void __glXDisp_Materiali(GLbyte * pc)
1001 {
1002     CALL_Materiali( GET_DISPATCH(), (
1003         *(GLenum   *)(pc +  0),
1004         *(GLenum   *)(pc +  4),
1005         *(GLint    *)(pc +  8)
1006     ) );
1007 }
1008
1009 void __glXDisp_Materialiv(GLbyte * pc)
1010 {
1011     const GLenum pname = *(GLenum   *)(pc +  4);
1012     const GLint * params;
1013
1014     params = (const GLint *) (pc + 8);
1015
1016     CALL_Materialiv( GET_DISPATCH(), (
1017         *(GLenum   *)(pc +  0),
1018         pname,
1019         params
1020     ) );
1021 }
1022
1023 void __glXDisp_PointSize(GLbyte * pc)
1024 {
1025     CALL_PointSize( GET_DISPATCH(), (
1026         *(GLfloat  *)(pc +  0)
1027     ) );
1028 }
1029
1030 void __glXDisp_PolygonMode(GLbyte * pc)
1031 {
1032     CALL_PolygonMode( GET_DISPATCH(), (
1033         *(GLenum   *)(pc +  0),
1034         *(GLenum   *)(pc +  4)
1035     ) );
1036 }
1037
1038 void __glXDisp_PolygonStipple(GLbyte * pc)
1039 {
1040     const GLubyte * const mask = (const GLubyte *) (pc + 20);
1041     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
1042
1043     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
1044     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
1045     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
1046     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
1047     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
1048
1049     CALL_PolygonStipple( GET_DISPATCH(), (
1050         mask
1051     ) );
1052 }
1053
1054 void __glXDisp_Scissor(GLbyte * pc)
1055 {
1056     CALL_Scissor( GET_DISPATCH(), (
1057         *(GLint    *)(pc +  0),
1058         *(GLint    *)(pc +  4),
1059         *(GLsizei  *)(pc +  8),
1060         *(GLsizei  *)(pc + 12)
1061     ) );
1062 }
1063
1064 void __glXDisp_ShadeModel(GLbyte * pc)
1065 {
1066     CALL_ShadeModel( GET_DISPATCH(), (
1067         *(GLenum   *)(pc +  0)
1068     ) );
1069 }
1070
1071 void __glXDisp_TexParameterf(GLbyte * pc)
1072 {
1073     CALL_TexParameterf( GET_DISPATCH(), (
1074         *(GLenum   *)(pc +  0),
1075         *(GLenum   *)(pc +  4),
1076         *(GLfloat  *)(pc +  8)
1077     ) );
1078 }
1079
1080 void __glXDisp_TexParameterfv(GLbyte * pc)
1081 {
1082     const GLenum pname = *(GLenum   *)(pc +  4);
1083     const GLfloat * params;
1084
1085     params = (const GLfloat *) (pc + 8);
1086
1087     CALL_TexParameterfv( GET_DISPATCH(), (
1088         *(GLenum   *)(pc +  0),
1089         pname,
1090         params
1091     ) );
1092 }
1093
1094 void __glXDisp_TexParameteri(GLbyte * pc)
1095 {
1096     CALL_TexParameteri( GET_DISPATCH(), (
1097         *(GLenum   *)(pc +  0),
1098         *(GLenum   *)(pc +  4),
1099         *(GLint    *)(pc +  8)
1100     ) );
1101 }
1102
1103 void __glXDisp_TexParameteriv(GLbyte * pc)
1104 {
1105     const GLenum pname = *(GLenum   *)(pc +  4);
1106     const GLint * params;
1107
1108     params = (const GLint *) (pc + 8);
1109
1110     CALL_TexParameteriv( GET_DISPATCH(), (
1111         *(GLenum   *)(pc +  0),
1112         pname,
1113         params
1114     ) );
1115 }
1116
1117 void __glXDisp_TexImage1D(GLbyte * pc)
1118 {
1119     const GLvoid * const pixels = (const GLvoid *) (pc + 52);
1120     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
1121
1122     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
1123     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
1124     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
1125     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
1126     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
1127     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
1128
1129     CALL_TexImage1D( GET_DISPATCH(), (
1130         *(GLenum   *)(pc + 20),
1131         *(GLint    *)(pc + 24),
1132         *(GLint    *)(pc + 28),
1133         *(GLsizei  *)(pc + 32),
1134         *(GLint    *)(pc + 40),
1135         *(GLenum   *)(pc + 44),
1136         *(GLenum   *)(pc + 48),
1137         pixels
1138     ) );
1139 }
1140
1141 void __glXDisp_TexImage2D(GLbyte * pc)
1142 {
1143     const GLvoid * const pixels = (const GLvoid *) (pc + 52);
1144     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
1145
1146     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
1147     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
1148     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
1149     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
1150     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
1151     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
1152
1153     CALL_TexImage2D( GET_DISPATCH(), (
1154         *(GLenum   *)(pc + 20),
1155         *(GLint    *)(pc + 24),
1156         *(GLint    *)(pc + 28),
1157         *(GLsizei  *)(pc + 32),
1158         *(GLsizei  *)(pc + 36),
1159         *(GLint    *)(pc + 40),
1160         *(GLenum   *)(pc + 44),
1161         *(GLenum   *)(pc + 48),
1162         pixels
1163     ) );
1164 }
1165
1166 void __glXDisp_TexEnvf(GLbyte * pc)
1167 {
1168     CALL_TexEnvf( GET_DISPATCH(), (
1169         *(GLenum   *)(pc +  0),
1170         *(GLenum   *)(pc +  4),
1171         *(GLfloat  *)(pc +  8)
1172     ) );
1173 }
1174
1175 void __glXDisp_TexEnvfv(GLbyte * pc)
1176 {
1177     const GLenum pname = *(GLenum   *)(pc +  4);
1178     const GLfloat * params;
1179
1180     params = (const GLfloat *) (pc + 8);
1181
1182     CALL_TexEnvfv( GET_DISPATCH(), (
1183         *(GLenum   *)(pc +  0),
1184         pname,
1185         params
1186     ) );
1187 }
1188
1189 void __glXDisp_TexEnvi(GLbyte * pc)
1190 {
1191     CALL_TexEnvi( GET_DISPATCH(), (
1192         *(GLenum   *)(pc +  0),
1193         *(GLenum   *)(pc +  4),
1194         *(GLint    *)(pc +  8)
1195     ) );
1196 }
1197
1198 void __glXDisp_TexEnviv(GLbyte * pc)
1199 {
1200     const GLenum pname = *(GLenum   *)(pc +  4);
1201     const GLint * params;
1202
1203     params = (const GLint *) (pc + 8);
1204
1205     CALL_TexEnviv( GET_DISPATCH(), (
1206         *(GLenum   *)(pc +  0),
1207         pname,
1208         params
1209     ) );
1210 }
1211
1212 void __glXDisp_TexGend(GLbyte * pc)
1213 {
1214 #ifdef __GLX_ALIGN64
1215     if ((unsigned long)(pc) & 7) {
1216         (void) memmove(pc-4, pc, 16);
1217         pc -= 4;
1218     }
1219 #endif
1220
1221     CALL_TexGend( GET_DISPATCH(), (
1222         *(GLenum   *)(pc +  8),
1223         *(GLenum   *)(pc + 12),
1224         *(GLdouble *)(pc +  0)
1225     ) );
1226 }
1227
1228 void __glXDisp_TexGendv(GLbyte * pc)
1229 {
1230     const GLenum pname = *(GLenum   *)(pc +  4);
1231     const GLdouble * params;
1232
1233 #ifdef __GLX_ALIGN64
1234     const GLuint compsize = __glTexGendv_size(pname);
1235     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
1236     if ((unsigned long)(pc) & 7) {
1237         (void) memmove(pc-4, pc, cmdlen);
1238         pc -= 4;
1239     }
1240 #endif
1241
1242     params = (const GLdouble *) (pc + 8);
1243
1244     CALL_TexGendv( GET_DISPATCH(), (
1245         *(GLenum   *)(pc +  0),
1246         pname,
1247         params
1248     ) );
1249 }
1250
1251 void __glXDisp_TexGenf(GLbyte * pc)
1252 {
1253     CALL_TexGenf( GET_DISPATCH(), (
1254         *(GLenum   *)(pc +  0),
1255         *(GLenum   *)(pc +  4),
1256         *(GLfloat  *)(pc +  8)
1257     ) );
1258 }
1259
1260 void __glXDisp_TexGenfv(GLbyte * pc)
1261 {
1262     const GLenum pname = *(GLenum   *)(pc +  4);
1263     const GLfloat * params;
1264
1265     params = (const GLfloat *) (pc + 8);
1266
1267     CALL_TexGenfv( GET_DISPATCH(), (
1268         *(GLenum   *)(pc +  0),
1269         pname,
1270         params
1271     ) );
1272 }
1273
1274 void __glXDisp_TexGeni(GLbyte * pc)
1275 {
1276     CALL_TexGeni( GET_DISPATCH(), (
1277         *(GLenum   *)(pc +  0),
1278         *(GLenum   *)(pc +  4),
1279         *(GLint    *)(pc +  8)
1280     ) );
1281 }
1282
1283 void __glXDisp_TexGeniv(GLbyte * pc)
1284 {
1285     const GLenum pname = *(GLenum   *)(pc +  4);
1286     const GLint * params;
1287
1288     params = (const GLint *) (pc + 8);
1289
1290     CALL_TexGeniv( GET_DISPATCH(), (
1291         *(GLenum   *)(pc +  0),
1292         pname,
1293         params
1294     ) );
1295 }
1296
1297 void __glXDisp_InitNames(GLbyte * pc)
1298 {
1299     CALL_InitNames( GET_DISPATCH(), () );
1300 }
1301
1302 void __glXDisp_LoadName(GLbyte * pc)
1303 {
1304     CALL_LoadName( GET_DISPATCH(), (
1305         *(GLuint   *)(pc +  0)
1306     ) );
1307 }
1308
1309 void __glXDisp_PassThrough(GLbyte * pc)
1310 {
1311     CALL_PassThrough( GET_DISPATCH(), (
1312         *(GLfloat  *)(pc +  0)
1313     ) );
1314 }
1315
1316 void __glXDisp_PopName(GLbyte * pc)
1317 {
1318     CALL_PopName( GET_DISPATCH(), () );
1319 }
1320
1321 void __glXDisp_PushName(GLbyte * pc)
1322 {
1323     CALL_PushName( GET_DISPATCH(), (
1324         *(GLuint   *)(pc +  0)
1325     ) );
1326 }
1327
1328 void __glXDisp_DrawBuffer(GLbyte * pc)
1329 {
1330     CALL_DrawBuffer( GET_DISPATCH(), (
1331         *(GLenum   *)(pc +  0)
1332     ) );
1333 }
1334
1335 void __glXDisp_Clear(GLbyte * pc)
1336 {
1337     CALL_Clear( GET_DISPATCH(), (
1338         *(GLbitfield *)(pc +  0)
1339     ) );
1340 }
1341
1342 void __glXDisp_ClearAccum(GLbyte * pc)
1343 {
1344     CALL_ClearAccum( GET_DISPATCH(), (
1345         *(GLfloat  *)(pc +  0),
1346         *(GLfloat  *)(pc +  4),
1347         *(GLfloat  *)(pc +  8),
1348         *(GLfloat  *)(pc + 12)
1349     ) );
1350 }
1351
1352 void __glXDisp_ClearIndex(GLbyte * pc)
1353 {
1354     CALL_ClearIndex( GET_DISPATCH(), (
1355         *(GLfloat  *)(pc +  0)
1356     ) );
1357 }
1358
1359 void __glXDisp_ClearColor(GLbyte * pc)
1360 {
1361     CALL_ClearColor( GET_DISPATCH(), (
1362         *(GLclampf *)(pc +  0),
1363         *(GLclampf *)(pc +  4),
1364         *(GLclampf *)(pc +  8),
1365         *(GLclampf *)(pc + 12)
1366     ) );
1367 }
1368
1369 void __glXDisp_ClearStencil(GLbyte * pc)
1370 {
1371     CALL_ClearStencil( GET_DISPATCH(), (
1372         *(GLint    *)(pc +  0)
1373     ) );
1374 }
1375
1376 void __glXDisp_ClearDepth(GLbyte * pc)
1377 {
1378 #ifdef __GLX_ALIGN64
1379     if ((unsigned long)(pc) & 7) {
1380         (void) memmove(pc-4, pc, 8);
1381         pc -= 4;
1382     }
1383 #endif
1384
1385     CALL_ClearDepth( GET_DISPATCH(), (
1386         *(GLclampd *)(pc +  0)
1387     ) );
1388 }
1389
1390 void __glXDisp_StencilMask(GLbyte * pc)
1391 {
1392     CALL_StencilMask( GET_DISPATCH(), (
1393         *(GLuint   *)(pc +  0)
1394     ) );
1395 }
1396
1397 void __glXDisp_ColorMask(GLbyte * pc)
1398 {
1399     CALL_ColorMask( GET_DISPATCH(), (
1400         *(GLboolean *)(pc +  0),
1401         *(GLboolean *)(pc +  1),
1402         *(GLboolean *)(pc +  2),
1403         *(GLboolean *)(pc +  3)
1404     ) );
1405 }
1406
1407 void __glXDisp_DepthMask(GLbyte * pc)
1408 {
1409     CALL_DepthMask( GET_DISPATCH(), (
1410         *(GLboolean *)(pc +  0)
1411     ) );
1412 }
1413
1414 void __glXDisp_IndexMask(GLbyte * pc)
1415 {
1416     CALL_IndexMask( GET_DISPATCH(), (
1417         *(GLuint   *)(pc +  0)
1418     ) );
1419 }
1420
1421 void __glXDisp_Accum(GLbyte * pc)
1422 {
1423     CALL_Accum( GET_DISPATCH(), (
1424         *(GLenum   *)(pc +  0),
1425         *(GLfloat  *)(pc +  4)
1426     ) );
1427 }
1428
1429 void __glXDisp_Disable(GLbyte * pc)
1430 {
1431     CALL_Disable( GET_DISPATCH(), (
1432         *(GLenum   *)(pc +  0)
1433     ) );
1434 }
1435
1436 void __glXDisp_Enable(GLbyte * pc)
1437 {
1438     CALL_Enable( GET_DISPATCH(), (
1439         *(GLenum   *)(pc +  0)
1440     ) );
1441 }
1442
1443 void __glXDisp_PopAttrib(GLbyte * pc)
1444 {
1445     CALL_PopAttrib( GET_DISPATCH(), () );
1446 }
1447
1448 void __glXDisp_PushAttrib(GLbyte * pc)
1449 {
1450     CALL_PushAttrib( GET_DISPATCH(), (
1451         *(GLbitfield *)(pc +  0)
1452     ) );
1453 }
1454
1455 void __glXDisp_MapGrid1d(GLbyte * pc)
1456 {
1457 #ifdef __GLX_ALIGN64
1458     if ((unsigned long)(pc) & 7) {
1459         (void) memmove(pc-4, pc, 20);
1460         pc -= 4;
1461     }
1462 #endif
1463
1464     CALL_MapGrid1d( GET_DISPATCH(), (
1465         *(GLint    *)(pc + 16),
1466         *(GLdouble *)(pc +  0),
1467         *(GLdouble *)(pc +  8)
1468     ) );
1469 }
1470
1471 void __glXDisp_MapGrid1f(GLbyte * pc)
1472 {
1473     CALL_MapGrid1f( GET_DISPATCH(), (
1474         *(GLint    *)(pc +  0),
1475         *(GLfloat  *)(pc +  4),
1476         *(GLfloat  *)(pc +  8)
1477     ) );
1478 }
1479
1480 void __glXDisp_MapGrid2d(GLbyte * pc)
1481 {
1482 #ifdef __GLX_ALIGN64
1483     if ((unsigned long)(pc) & 7) {
1484         (void) memmove(pc-4, pc, 40);
1485         pc -= 4;
1486     }
1487 #endif
1488
1489     CALL_MapGrid2d( GET_DISPATCH(), (
1490         *(GLint    *)(pc + 32),
1491         *(GLdouble *)(pc +  0),
1492         *(GLdouble *)(pc +  8),
1493         *(GLint    *)(pc + 36),
1494         *(GLdouble *)(pc + 16),
1495         *(GLdouble *)(pc + 24)
1496     ) );
1497 }
1498
1499 void __glXDisp_MapGrid2f(GLbyte * pc)
1500 {
1501     CALL_MapGrid2f( GET_DISPATCH(), (
1502         *(GLint    *)(pc +  0),
1503         *(GLfloat  *)(pc +  4),
1504         *(GLfloat  *)(pc +  8),
1505         *(GLint    *)(pc + 12),
1506         *(GLfloat  *)(pc + 16),
1507         *(GLfloat  *)(pc + 20)
1508     ) );
1509 }
1510
1511 void __glXDisp_EvalCoord1dv(GLbyte * pc)
1512 {
1513 #ifdef __GLX_ALIGN64
1514     if ((unsigned long)(pc) & 7) {
1515         (void) memmove(pc-4, pc, 8);
1516         pc -= 4;
1517     }
1518 #endif
1519
1520     CALL_EvalCoord1dv( GET_DISPATCH(), (
1521          (const GLdouble *)(pc +  0)
1522     ) );
1523 }
1524
1525 void __glXDisp_EvalCoord1fv(GLbyte * pc)
1526 {
1527     CALL_EvalCoord1fv( GET_DISPATCH(), (
1528          (const GLfloat *)(pc +  0)
1529     ) );
1530 }
1531
1532 void __glXDisp_EvalCoord2dv(GLbyte * pc)
1533 {
1534 #ifdef __GLX_ALIGN64
1535     if ((unsigned long)(pc) & 7) {
1536         (void) memmove(pc-4, pc, 16);
1537         pc -= 4;
1538     }
1539 #endif
1540
1541     CALL_EvalCoord2dv( GET_DISPATCH(), (
1542          (const GLdouble *)(pc +  0)
1543     ) );
1544 }
1545
1546 void __glXDisp_EvalCoord2fv(GLbyte * pc)
1547 {
1548     CALL_EvalCoord2fv( GET_DISPATCH(), (
1549          (const GLfloat *)(pc +  0)
1550     ) );
1551 }
1552
1553 void __glXDisp_EvalMesh1(GLbyte * pc)
1554 {
1555     CALL_EvalMesh1( GET_DISPATCH(), (
1556         *(GLenum   *)(pc +  0),
1557         *(GLint    *)(pc +  4),
1558         *(GLint    *)(pc +  8)
1559     ) );
1560 }
1561
1562 void __glXDisp_EvalPoint1(GLbyte * pc)
1563 {
1564     CALL_EvalPoint1( GET_DISPATCH(), (
1565         *(GLint    *)(pc +  0)
1566     ) );
1567 }
1568
1569 void __glXDisp_EvalMesh2(GLbyte * pc)
1570 {
1571     CALL_EvalMesh2( GET_DISPATCH(), (
1572         *(GLenum   *)(pc +  0),
1573         *(GLint    *)(pc +  4),
1574         *(GLint    *)(pc +  8),
1575         *(GLint    *)(pc + 12),
1576         *(GLint    *)(pc + 16)
1577     ) );
1578 }
1579
1580 void __glXDisp_EvalPoint2(GLbyte * pc)
1581 {
1582     CALL_EvalPoint2( GET_DISPATCH(), (
1583         *(GLint    *)(pc +  0),
1584         *(GLint    *)(pc +  4)
1585     ) );
1586 }
1587
1588 void __glXDisp_AlphaFunc(GLbyte * pc)
1589 {
1590     CALL_AlphaFunc( GET_DISPATCH(), (
1591         *(GLenum   *)(pc +  0),
1592         *(GLclampf *)(pc +  4)
1593     ) );
1594 }
1595
1596 void __glXDisp_BlendFunc(GLbyte * pc)
1597 {
1598     CALL_BlendFunc( GET_DISPATCH(), (
1599         *(GLenum   *)(pc +  0),
1600         *(GLenum   *)(pc +  4)
1601     ) );
1602 }
1603
1604 void __glXDisp_LogicOp(GLbyte * pc)
1605 {
1606     CALL_LogicOp( GET_DISPATCH(), (
1607         *(GLenum   *)(pc +  0)
1608     ) );
1609 }
1610
1611 void __glXDisp_StencilFunc(GLbyte * pc)
1612 {
1613     CALL_StencilFunc( GET_DISPATCH(), (
1614         *(GLenum   *)(pc +  0),
1615         *(GLint    *)(pc +  4),
1616         *(GLuint   *)(pc +  8)
1617     ) );
1618 }
1619
1620 void __glXDisp_StencilOp(GLbyte * pc)
1621 {
1622     CALL_StencilOp( GET_DISPATCH(), (
1623         *(GLenum   *)(pc +  0),
1624         *(GLenum   *)(pc +  4),
1625         *(GLenum   *)(pc +  8)
1626     ) );
1627 }
1628
1629 void __glXDisp_DepthFunc(GLbyte * pc)
1630 {
1631     CALL_DepthFunc( GET_DISPATCH(), (
1632         *(GLenum   *)(pc +  0)
1633     ) );
1634 }
1635
1636 void __glXDisp_PixelZoom(GLbyte * pc)
1637 {
1638     CALL_PixelZoom( GET_DISPATCH(), (
1639         *(GLfloat  *)(pc +  0),
1640         *(GLfloat  *)(pc +  4)
1641     ) );
1642 }
1643
1644 void __glXDisp_PixelTransferf(GLbyte * pc)
1645 {
1646     CALL_PixelTransferf( GET_DISPATCH(), (
1647         *(GLenum   *)(pc +  0),
1648         *(GLfloat  *)(pc +  4)
1649     ) );
1650 }
1651
1652 void __glXDisp_PixelTransferi(GLbyte * pc)
1653 {
1654     CALL_PixelTransferi( GET_DISPATCH(), (
1655         *(GLenum   *)(pc +  0),
1656         *(GLint    *)(pc +  4)
1657     ) );
1658 }
1659
1660 int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc)
1661 {
1662     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1663     int error;
1664     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1665
1666     pc += __GLX_SINGLE_HDR_SIZE;
1667     if ( cx != NULL ) {
1668         CALL_PixelStoref( GET_DISPATCH(), (
1669             *(GLenum   *)(pc +  0),
1670             *(GLfloat  *)(pc +  4)
1671         ) );
1672         error = Success;
1673     }
1674
1675     return error;
1676 }
1677
1678 int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc)
1679 {
1680     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1681     int error;
1682     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1683
1684     pc += __GLX_SINGLE_HDR_SIZE;
1685     if ( cx != NULL ) {
1686         CALL_PixelStorei( GET_DISPATCH(), (
1687             *(GLenum   *)(pc +  0),
1688             *(GLint    *)(pc +  4)
1689         ) );
1690         error = Success;
1691     }
1692
1693     return error;
1694 }
1695
1696 void __glXDisp_PixelMapfv(GLbyte * pc)
1697 {
1698     const GLsizei mapsize = *(GLsizei  *)(pc +  4);
1699
1700     CALL_PixelMapfv( GET_DISPATCH(), (
1701         *(GLenum   *)(pc +  0),
1702         mapsize,
1703          (const GLfloat *)(pc +  8)
1704     ) );
1705 }
1706
1707 void __glXDisp_PixelMapuiv(GLbyte * pc)
1708 {
1709     const GLsizei mapsize = *(GLsizei  *)(pc +  4);
1710
1711     CALL_PixelMapuiv( GET_DISPATCH(), (
1712         *(GLenum   *)(pc +  0),
1713         mapsize,
1714          (const GLuint *)(pc +  8)
1715     ) );
1716 }
1717
1718 void __glXDisp_PixelMapusv(GLbyte * pc)
1719 {
1720     const GLsizei mapsize = *(GLsizei  *)(pc +  4);
1721
1722     CALL_PixelMapusv( GET_DISPATCH(), (
1723         *(GLenum   *)(pc +  0),
1724         mapsize,
1725          (const GLushort *)(pc +  8)
1726     ) );
1727 }
1728
1729 void __glXDisp_ReadBuffer(GLbyte * pc)
1730 {
1731     CALL_ReadBuffer( GET_DISPATCH(), (
1732         *(GLenum   *)(pc +  0)
1733     ) );
1734 }
1735
1736 void __glXDisp_CopyPixels(GLbyte * pc)
1737 {
1738     CALL_CopyPixels( GET_DISPATCH(), (
1739         *(GLint    *)(pc +  0),
1740         *(GLint    *)(pc +  4),
1741         *(GLsizei  *)(pc +  8),
1742         *(GLsizei  *)(pc + 12),
1743         *(GLenum   *)(pc + 16)
1744     ) );
1745 }
1746
1747 void __glXDisp_DrawPixels(GLbyte * pc)
1748 {
1749     const GLvoid * const pixels = (const GLvoid *) (pc + 36);
1750     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
1751
1752     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
1753     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
1754     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
1755     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
1756     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
1757     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
1758
1759     CALL_DrawPixels( GET_DISPATCH(), (
1760         *(GLsizei  *)(pc + 20),
1761         *(GLsizei  *)(pc + 24),
1762         *(GLenum   *)(pc + 28),
1763         *(GLenum   *)(pc + 32),
1764         pixels
1765     ) );
1766 }
1767
1768 int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
1769 {
1770     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1771     int error;
1772     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1773
1774     pc += __GLX_SINGLE_HDR_SIZE;
1775     if ( cx != NULL ) {
1776         const GLenum pname = *(GLenum   *)(pc +  0);
1777
1778         const GLuint compsize = __glGetBooleanv_size(pname);
1779         GLboolean answerBuffer[200];
1780         GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1);
1781
1782         if (params == NULL) return BadAlloc;
1783         __glXClearErrorOccured();
1784
1785         CALL_GetBooleanv( GET_DISPATCH(), (
1786             pname,
1787             params
1788         ) );
1789         __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
1790         error = Success;
1791     }
1792
1793     return error;
1794 }
1795
1796 int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
1797 {
1798     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1799     int error;
1800     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1801
1802     pc += __GLX_SINGLE_HDR_SIZE;
1803     if ( cx != NULL ) {
1804         GLdouble equation[4];
1805         CALL_GetClipPlane( GET_DISPATCH(), (
1806             *(GLenum   *)(pc +  0),
1807             equation
1808         ) );
1809         __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
1810         error = Success;
1811     }
1812
1813     return error;
1814 }
1815
1816 int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc)
1817 {
1818     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1819     int error;
1820     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1821
1822     pc += __GLX_SINGLE_HDR_SIZE;
1823     if ( cx != NULL ) {
1824         const GLenum pname = *(GLenum   *)(pc +  0);
1825
1826         const GLuint compsize = __glGetDoublev_size(pname);
1827         GLdouble answerBuffer[200];
1828         GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
1829
1830         if (params == NULL) return BadAlloc;
1831         __glXClearErrorOccured();
1832
1833         CALL_GetDoublev( GET_DISPATCH(), (
1834             pname,
1835             params
1836         ) );
1837         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
1838         error = Success;
1839     }
1840
1841     return error;
1842 }
1843
1844 int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
1845 {
1846     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1847     int error;
1848     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1849
1850     pc += __GLX_SINGLE_HDR_SIZE;
1851     if ( cx != NULL ) {
1852         GLenum retval;
1853         retval = CALL_GetError( GET_DISPATCH(), () );
1854         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
1855         error = Success;
1856     }
1857
1858     return error;
1859 }
1860
1861 int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc)
1862 {
1863     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1864     int error;
1865     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1866
1867     pc += __GLX_SINGLE_HDR_SIZE;
1868     if ( cx != NULL ) {
1869         const GLenum pname = *(GLenum   *)(pc +  0);
1870
1871         const GLuint compsize = __glGetFloatv_size(pname);
1872         GLfloat answerBuffer[200];
1873         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
1874
1875         if (params == NULL) return BadAlloc;
1876         __glXClearErrorOccured();
1877
1878         CALL_GetFloatv( GET_DISPATCH(), (
1879             pname,
1880             params
1881         ) );
1882         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
1883         error = Success;
1884     }
1885
1886     return error;
1887 }
1888
1889 int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
1890 {
1891     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1892     int error;
1893     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1894
1895     pc += __GLX_SINGLE_HDR_SIZE;
1896     if ( cx != NULL ) {
1897         const GLenum pname = *(GLenum   *)(pc +  0);
1898
1899         const GLuint compsize = __glGetIntegerv_size(pname);
1900         GLint answerBuffer[200];
1901         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
1902
1903         if (params == NULL) return BadAlloc;
1904         __glXClearErrorOccured();
1905
1906         CALL_GetIntegerv( GET_DISPATCH(), (
1907             pname,
1908             params
1909         ) );
1910         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
1911         error = Success;
1912     }
1913
1914     return error;
1915 }
1916
1917 int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc)
1918 {
1919     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1920     int error;
1921     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1922
1923     pc += __GLX_SINGLE_HDR_SIZE;
1924     if ( cx != NULL ) {
1925         const GLenum pname = *(GLenum   *)(pc +  4);
1926
1927         const GLuint compsize = __glGetLightfv_size(pname);
1928         GLfloat answerBuffer[200];
1929         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
1930
1931         if (params == NULL) return BadAlloc;
1932         __glXClearErrorOccured();
1933
1934         CALL_GetLightfv( GET_DISPATCH(), (
1935             *(GLenum   *)(pc +  0),
1936             pname,
1937             params
1938         ) );
1939         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
1940         error = Success;
1941     }
1942
1943     return error;
1944 }
1945
1946 int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc)
1947 {
1948     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1949     int error;
1950     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1951
1952     pc += __GLX_SINGLE_HDR_SIZE;
1953     if ( cx != NULL ) {
1954         const GLenum pname = *(GLenum   *)(pc +  4);
1955
1956         const GLuint compsize = __glGetLightiv_size(pname);
1957         GLint answerBuffer[200];
1958         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
1959
1960         if (params == NULL) return BadAlloc;
1961         __glXClearErrorOccured();
1962
1963         CALL_GetLightiv( GET_DISPATCH(), (
1964             *(GLenum   *)(pc +  0),
1965             pname,
1966             params
1967         ) );
1968         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
1969         error = Success;
1970     }
1971
1972     return error;
1973 }
1974
1975 int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc)
1976 {
1977     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
1978     int error;
1979     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
1980
1981     pc += __GLX_SINGLE_HDR_SIZE;
1982     if ( cx != NULL ) {
1983         const GLenum target = *(GLenum   *)(pc +  0);
1984         const GLenum query = *(GLenum   *)(pc +  4);
1985
1986         const GLuint compsize = __glGetMapdv_size(target,query);
1987         GLdouble answerBuffer[200];
1988         GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
1989
1990         if (v == NULL) return BadAlloc;
1991         __glXClearErrorOccured();
1992
1993         CALL_GetMapdv( GET_DISPATCH(), (
1994             target,
1995             query,
1996             v
1997         ) );
1998         __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
1999         error = Success;
2000     }
2001
2002     return error;
2003 }
2004
2005 int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc)
2006 {
2007     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2008     int error;
2009     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2010
2011     pc += __GLX_SINGLE_HDR_SIZE;
2012     if ( cx != NULL ) {
2013         const GLenum target = *(GLenum   *)(pc +  0);
2014         const GLenum query = *(GLenum   *)(pc +  4);
2015
2016         const GLuint compsize = __glGetMapfv_size(target,query);
2017         GLfloat answerBuffer[200];
2018         GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2019
2020         if (v == NULL) return BadAlloc;
2021         __glXClearErrorOccured();
2022
2023         CALL_GetMapfv( GET_DISPATCH(), (
2024             target,
2025             query,
2026             v
2027         ) );
2028         __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
2029         error = Success;
2030     }
2031
2032     return error;
2033 }
2034
2035 int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
2036 {
2037     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2038     int error;
2039     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2040
2041     pc += __GLX_SINGLE_HDR_SIZE;
2042     if ( cx != NULL ) {
2043         const GLenum target = *(GLenum   *)(pc +  0);
2044         const GLenum query = *(GLenum   *)(pc +  4);
2045
2046         const GLuint compsize = __glGetMapiv_size(target,query);
2047         GLint answerBuffer[200];
2048         GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2049
2050         if (v == NULL) return BadAlloc;
2051         __glXClearErrorOccured();
2052
2053         CALL_GetMapiv( GET_DISPATCH(), (
2054             target,
2055             query,
2056             v
2057         ) );
2058         __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
2059         error = Success;
2060     }
2061
2062     return error;
2063 }
2064
2065 int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
2066 {
2067     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2068     int error;
2069     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2070
2071     pc += __GLX_SINGLE_HDR_SIZE;
2072     if ( cx != NULL ) {
2073         const GLenum pname = *(GLenum   *)(pc +  4);
2074
2075         const GLuint compsize = __glGetMaterialfv_size(pname);
2076         GLfloat answerBuffer[200];
2077         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2078
2079         if (params == NULL) return BadAlloc;
2080         __glXClearErrorOccured();
2081
2082         CALL_GetMaterialfv( GET_DISPATCH(), (
2083             *(GLenum   *)(pc +  0),
2084             pname,
2085             params
2086         ) );
2087         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2088         error = Success;
2089     }
2090
2091     return error;
2092 }
2093
2094 int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
2095 {
2096     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2097     int error;
2098     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2099
2100     pc += __GLX_SINGLE_HDR_SIZE;
2101     if ( cx != NULL ) {
2102         const GLenum pname = *(GLenum   *)(pc +  4);
2103
2104         const GLuint compsize = __glGetMaterialiv_size(pname);
2105         GLint answerBuffer[200];
2106         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2107
2108         if (params == NULL) return BadAlloc;
2109         __glXClearErrorOccured();
2110
2111         CALL_GetMaterialiv( GET_DISPATCH(), (
2112             *(GLenum   *)(pc +  0),
2113             pname,
2114             params
2115         ) );
2116         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2117         error = Success;
2118     }
2119
2120     return error;
2121 }
2122
2123 int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
2124 {
2125     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2126     int error;
2127     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2128
2129     pc += __GLX_SINGLE_HDR_SIZE;
2130     if ( cx != NULL ) {
2131         const GLenum map = *(GLenum   *)(pc +  0);
2132
2133         const GLuint compsize = __glGetPixelMapfv_size(map);
2134         GLfloat answerBuffer[200];
2135         GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2136
2137         if (values == NULL) return BadAlloc;
2138         __glXClearErrorOccured();
2139
2140         CALL_GetPixelMapfv( GET_DISPATCH(), (
2141             map,
2142             values
2143         ) );
2144         __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
2145         error = Success;
2146     }
2147
2148     return error;
2149 }
2150
2151 int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
2152 {
2153     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2154     int error;
2155     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2156
2157     pc += __GLX_SINGLE_HDR_SIZE;
2158     if ( cx != NULL ) {
2159         const GLenum map = *(GLenum   *)(pc +  0);
2160
2161         const GLuint compsize = __glGetPixelMapuiv_size(map);
2162         GLuint answerBuffer[200];
2163         GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2164
2165         if (values == NULL) return BadAlloc;
2166         __glXClearErrorOccured();
2167
2168         CALL_GetPixelMapuiv( GET_DISPATCH(), (
2169             map,
2170             values
2171         ) );
2172         __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
2173         error = Success;
2174     }
2175
2176     return error;
2177 }
2178
2179 int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
2180 {
2181     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2182     int error;
2183     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2184
2185     pc += __GLX_SINGLE_HDR_SIZE;
2186     if ( cx != NULL ) {
2187         const GLenum map = *(GLenum   *)(pc +  0);
2188
2189         const GLuint compsize = __glGetPixelMapusv_size(map);
2190         GLushort answerBuffer[200];
2191         GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
2192
2193         if (values == NULL) return BadAlloc;
2194         __glXClearErrorOccured();
2195
2196         CALL_GetPixelMapusv( GET_DISPATCH(), (
2197             map,
2198             values
2199         ) );
2200         __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
2201         error = Success;
2202     }
2203
2204     return error;
2205 }
2206
2207 int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
2208 {
2209     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2210     int error;
2211     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2212
2213     pc += __GLX_SINGLE_HDR_SIZE;
2214     if ( cx != NULL ) {
2215         const GLenum pname = *(GLenum   *)(pc +  4);
2216
2217         const GLuint compsize = __glGetTexEnvfv_size(pname);
2218         GLfloat answerBuffer[200];
2219         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2220
2221         if (params == NULL) return BadAlloc;
2222         __glXClearErrorOccured();
2223
2224         CALL_GetTexEnvfv( GET_DISPATCH(), (
2225             *(GLenum   *)(pc +  0),
2226             pname,
2227             params
2228         ) );
2229         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2230         error = Success;
2231     }
2232
2233     return error;
2234 }
2235
2236 int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
2237 {
2238     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2239     int error;
2240     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2241
2242     pc += __GLX_SINGLE_HDR_SIZE;
2243     if ( cx != NULL ) {
2244         const GLenum pname = *(GLenum   *)(pc +  4);
2245
2246         const GLuint compsize = __glGetTexEnviv_size(pname);
2247         GLint answerBuffer[200];
2248         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2249
2250         if (params == NULL) return BadAlloc;
2251         __glXClearErrorOccured();
2252
2253         CALL_GetTexEnviv( GET_DISPATCH(), (
2254             *(GLenum   *)(pc +  0),
2255             pname,
2256             params
2257         ) );
2258         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2259         error = Success;
2260     }
2261
2262     return error;
2263 }
2264
2265 int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
2266 {
2267     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2268     int error;
2269     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2270
2271     pc += __GLX_SINGLE_HDR_SIZE;
2272     if ( cx != NULL ) {
2273         const GLenum pname = *(GLenum   *)(pc +  4);
2274
2275         const GLuint compsize = __glGetTexGendv_size(pname);
2276         GLdouble answerBuffer[200];
2277         GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
2278
2279         if (params == NULL) return BadAlloc;
2280         __glXClearErrorOccured();
2281
2282         CALL_GetTexGendv( GET_DISPATCH(), (
2283             *(GLenum   *)(pc +  0),
2284             pname,
2285             params
2286         ) );
2287         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
2288         error = Success;
2289     }
2290
2291     return error;
2292 }
2293
2294 int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
2295 {
2296     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2297     int error;
2298     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2299
2300     pc += __GLX_SINGLE_HDR_SIZE;
2301     if ( cx != NULL ) {
2302         const GLenum pname = *(GLenum   *)(pc +  4);
2303
2304         const GLuint compsize = __glGetTexGenfv_size(pname);
2305         GLfloat answerBuffer[200];
2306         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2307
2308         if (params == NULL) return BadAlloc;
2309         __glXClearErrorOccured();
2310
2311         CALL_GetTexGenfv( GET_DISPATCH(), (
2312             *(GLenum   *)(pc +  0),
2313             pname,
2314             params
2315         ) );
2316         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2317         error = Success;
2318     }
2319
2320     return error;
2321 }
2322
2323 int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
2324 {
2325     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2326     int error;
2327     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2328
2329     pc += __GLX_SINGLE_HDR_SIZE;
2330     if ( cx != NULL ) {
2331         const GLenum pname = *(GLenum   *)(pc +  4);
2332
2333         const GLuint compsize = __glGetTexGeniv_size(pname);
2334         GLint answerBuffer[200];
2335         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2336
2337         if (params == NULL) return BadAlloc;
2338         __glXClearErrorOccured();
2339
2340         CALL_GetTexGeniv( GET_DISPATCH(), (
2341             *(GLenum   *)(pc +  0),
2342             pname,
2343             params
2344         ) );
2345         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2346         error = Success;
2347     }
2348
2349     return error;
2350 }
2351
2352 int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
2353 {
2354     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2355     int error;
2356     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2357
2358     pc += __GLX_SINGLE_HDR_SIZE;
2359     if ( cx != NULL ) {
2360         const GLenum pname = *(GLenum   *)(pc +  4);
2361
2362         const GLuint compsize = __glGetTexParameterfv_size(pname);
2363         GLfloat answerBuffer[200];
2364         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2365
2366         if (params == NULL) return BadAlloc;
2367         __glXClearErrorOccured();
2368
2369         CALL_GetTexParameterfv( GET_DISPATCH(), (
2370             *(GLenum   *)(pc +  0),
2371             pname,
2372             params
2373         ) );
2374         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2375         error = Success;
2376     }
2377
2378     return error;
2379 }
2380
2381 int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
2382 {
2383     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2384     int error;
2385     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2386
2387     pc += __GLX_SINGLE_HDR_SIZE;
2388     if ( cx != NULL ) {
2389         const GLenum pname = *(GLenum   *)(pc +  4);
2390
2391         const GLuint compsize = __glGetTexParameteriv_size(pname);
2392         GLint answerBuffer[200];
2393         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2394
2395         if (params == NULL) return BadAlloc;
2396         __glXClearErrorOccured();
2397
2398         CALL_GetTexParameteriv( GET_DISPATCH(), (
2399             *(GLenum   *)(pc +  0),
2400             pname,
2401             params
2402         ) );
2403         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2404         error = Success;
2405     }
2406
2407     return error;
2408 }
2409
2410 int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
2411 {
2412     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2413     int error;
2414     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2415
2416     pc += __GLX_SINGLE_HDR_SIZE;
2417     if ( cx != NULL ) {
2418         const GLenum pname = *(GLenum   *)(pc +  8);
2419
2420         const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
2421         GLfloat answerBuffer[200];
2422         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2423
2424         if (params == NULL) return BadAlloc;
2425         __glXClearErrorOccured();
2426
2427         CALL_GetTexLevelParameterfv( GET_DISPATCH(), (
2428             *(GLenum   *)(pc +  0),
2429             *(GLint    *)(pc +  4),
2430             pname,
2431             params
2432         ) );
2433         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2434         error = Success;
2435     }
2436
2437     return error;
2438 }
2439
2440 int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
2441 {
2442     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2443     int error;
2444     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2445
2446     pc += __GLX_SINGLE_HDR_SIZE;
2447     if ( cx != NULL ) {
2448         const GLenum pname = *(GLenum   *)(pc +  8);
2449
2450         const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
2451         GLint answerBuffer[200];
2452         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
2453
2454         if (params == NULL) return BadAlloc;
2455         __glXClearErrorOccured();
2456
2457         CALL_GetTexLevelParameteriv( GET_DISPATCH(), (
2458             *(GLenum   *)(pc +  0),
2459             *(GLint    *)(pc +  4),
2460             pname,
2461             params
2462         ) );
2463         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
2464         error = Success;
2465     }
2466
2467     return error;
2468 }
2469
2470 int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc)
2471 {
2472     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2473     int error;
2474     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2475
2476     pc += __GLX_SINGLE_HDR_SIZE;
2477     if ( cx != NULL ) {
2478         GLboolean retval;
2479         retval = CALL_IsEnabled( GET_DISPATCH(), (
2480             *(GLenum   *)(pc +  0)
2481         ) );
2482         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2483         error = Success;
2484     }
2485
2486     return error;
2487 }
2488
2489 int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc)
2490 {
2491     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2492     int error;
2493     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2494
2495     pc += __GLX_SINGLE_HDR_SIZE;
2496     if ( cx != NULL ) {
2497         GLboolean retval;
2498         retval = CALL_IsList( GET_DISPATCH(), (
2499             *(GLuint   *)(pc +  0)
2500         ) );
2501         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2502         error = Success;
2503     }
2504
2505     return error;
2506 }
2507
2508 void __glXDisp_DepthRange(GLbyte * pc)
2509 {
2510 #ifdef __GLX_ALIGN64
2511     if ((unsigned long)(pc) & 7) {
2512         (void) memmove(pc-4, pc, 16);
2513         pc -= 4;
2514     }
2515 #endif
2516
2517     CALL_DepthRange( GET_DISPATCH(), (
2518         *(GLclampd *)(pc +  0),
2519         *(GLclampd *)(pc +  8)
2520     ) );
2521 }
2522
2523 void __glXDisp_Frustum(GLbyte * pc)
2524 {
2525 #ifdef __GLX_ALIGN64
2526     if ((unsigned long)(pc) & 7) {
2527         (void) memmove(pc-4, pc, 48);
2528         pc -= 4;
2529     }
2530 #endif
2531
2532     CALL_Frustum( GET_DISPATCH(), (
2533         *(GLdouble *)(pc +  0),
2534         *(GLdouble *)(pc +  8),
2535         *(GLdouble *)(pc + 16),
2536         *(GLdouble *)(pc + 24),
2537         *(GLdouble *)(pc + 32),
2538         *(GLdouble *)(pc + 40)
2539     ) );
2540 }
2541
2542 void __glXDisp_LoadIdentity(GLbyte * pc)
2543 {
2544     CALL_LoadIdentity( GET_DISPATCH(), () );
2545 }
2546
2547 void __glXDisp_LoadMatrixf(GLbyte * pc)
2548 {
2549     CALL_LoadMatrixf( GET_DISPATCH(), (
2550          (const GLfloat *)(pc +  0)
2551     ) );
2552 }
2553
2554 void __glXDisp_LoadMatrixd(GLbyte * pc)
2555 {
2556 #ifdef __GLX_ALIGN64
2557     if ((unsigned long)(pc) & 7) {
2558         (void) memmove(pc-4, pc, 128);
2559         pc -= 4;
2560     }
2561 #endif
2562
2563     CALL_LoadMatrixd( GET_DISPATCH(), (
2564          (const GLdouble *)(pc +  0)
2565     ) );
2566 }
2567
2568 void __glXDisp_MatrixMode(GLbyte * pc)
2569 {
2570     CALL_MatrixMode( GET_DISPATCH(), (
2571         *(GLenum   *)(pc +  0)
2572     ) );
2573 }
2574
2575 void __glXDisp_MultMatrixf(GLbyte * pc)
2576 {
2577     CALL_MultMatrixf( GET_DISPATCH(), (
2578          (const GLfloat *)(pc +  0)
2579     ) );
2580 }
2581
2582 void __glXDisp_MultMatrixd(GLbyte * pc)
2583 {
2584 #ifdef __GLX_ALIGN64
2585     if ((unsigned long)(pc) & 7) {
2586         (void) memmove(pc-4, pc, 128);
2587         pc -= 4;
2588     }
2589 #endif
2590
2591     CALL_MultMatrixd( GET_DISPATCH(), (
2592          (const GLdouble *)(pc +  0)
2593     ) );
2594 }
2595
2596 void __glXDisp_Ortho(GLbyte * pc)
2597 {
2598 #ifdef __GLX_ALIGN64
2599     if ((unsigned long)(pc) & 7) {
2600         (void) memmove(pc-4, pc, 48);
2601         pc -= 4;
2602     }
2603 #endif
2604
2605     CALL_Ortho( GET_DISPATCH(), (
2606         *(GLdouble *)(pc +  0),
2607         *(GLdouble *)(pc +  8),
2608         *(GLdouble *)(pc + 16),
2609         *(GLdouble *)(pc + 24),
2610         *(GLdouble *)(pc + 32),
2611         *(GLdouble *)(pc + 40)
2612     ) );
2613 }
2614
2615 void __glXDisp_PopMatrix(GLbyte * pc)
2616 {
2617     CALL_PopMatrix( GET_DISPATCH(), () );
2618 }
2619
2620 void __glXDisp_PushMatrix(GLbyte * pc)
2621 {
2622     CALL_PushMatrix( GET_DISPATCH(), () );
2623 }
2624
2625 void __glXDisp_Rotated(GLbyte * pc)
2626 {
2627 #ifdef __GLX_ALIGN64
2628     if ((unsigned long)(pc) & 7) {
2629         (void) memmove(pc-4, pc, 32);
2630         pc -= 4;
2631     }
2632 #endif
2633
2634     CALL_Rotated( GET_DISPATCH(), (
2635         *(GLdouble *)(pc +  0),
2636         *(GLdouble *)(pc +  8),
2637         *(GLdouble *)(pc + 16),
2638         *(GLdouble *)(pc + 24)
2639     ) );
2640 }
2641
2642 void __glXDisp_Rotatef(GLbyte * pc)
2643 {
2644     CALL_Rotatef( GET_DISPATCH(), (
2645         *(GLfloat  *)(pc +  0),
2646         *(GLfloat  *)(pc +  4),
2647         *(GLfloat  *)(pc +  8),
2648         *(GLfloat  *)(pc + 12)
2649     ) );
2650 }
2651
2652 void __glXDisp_Scaled(GLbyte * pc)
2653 {
2654 #ifdef __GLX_ALIGN64
2655     if ((unsigned long)(pc) & 7) {
2656         (void) memmove(pc-4, pc, 24);
2657         pc -= 4;
2658     }
2659 #endif
2660
2661     CALL_Scaled( GET_DISPATCH(), (
2662         *(GLdouble *)(pc +  0),
2663         *(GLdouble *)(pc +  8),
2664         *(GLdouble *)(pc + 16)
2665     ) );
2666 }
2667
2668 void __glXDisp_Scalef(GLbyte * pc)
2669 {
2670     CALL_Scalef( GET_DISPATCH(), (
2671         *(GLfloat  *)(pc +  0),
2672         *(GLfloat  *)(pc +  4),
2673         *(GLfloat  *)(pc +  8)
2674     ) );
2675 }
2676
2677 void __glXDisp_Translated(GLbyte * pc)
2678 {
2679 #ifdef __GLX_ALIGN64
2680     if ((unsigned long)(pc) & 7) {
2681         (void) memmove(pc-4, pc, 24);
2682         pc -= 4;
2683     }
2684 #endif
2685
2686     CALL_Translated( GET_DISPATCH(), (
2687         *(GLdouble *)(pc +  0),
2688         *(GLdouble *)(pc +  8),
2689         *(GLdouble *)(pc + 16)
2690     ) );
2691 }
2692
2693 void __glXDisp_Translatef(GLbyte * pc)
2694 {
2695     CALL_Translatef( GET_DISPATCH(), (
2696         *(GLfloat  *)(pc +  0),
2697         *(GLfloat  *)(pc +  4),
2698         *(GLfloat  *)(pc +  8)
2699     ) );
2700 }
2701
2702 void __glXDisp_Viewport(GLbyte * pc)
2703 {
2704     CALL_Viewport( GET_DISPATCH(), (
2705         *(GLint    *)(pc +  0),
2706         *(GLint    *)(pc +  4),
2707         *(GLsizei  *)(pc +  8),
2708         *(GLsizei  *)(pc + 12)
2709     ) );
2710 }
2711
2712 void __glXDisp_BindTexture(GLbyte * pc)
2713 {
2714     CALL_BindTexture( GET_DISPATCH(), (
2715         *(GLenum   *)(pc +  0),
2716         *(GLuint   *)(pc +  4)
2717     ) );
2718 }
2719
2720 void __glXDisp_Indexubv(GLbyte * pc)
2721 {
2722     CALL_Indexubv( GET_DISPATCH(), (
2723          (const GLubyte *)(pc +  0)
2724     ) );
2725 }
2726
2727 void __glXDisp_PolygonOffset(GLbyte * pc)
2728 {
2729     CALL_PolygonOffset( GET_DISPATCH(), (
2730         *(GLfloat  *)(pc +  0),
2731         *(GLfloat  *)(pc +  4)
2732     ) );
2733 }
2734
2735 int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
2736 {
2737     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2738     int error;
2739     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2740
2741     pc += __GLX_SINGLE_HDR_SIZE;
2742     if ( cx != NULL ) {
2743         const GLsizei n = *(GLsizei  *)(pc +  0);
2744
2745         GLboolean retval;
2746         GLboolean answerBuffer[200];
2747         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
2748         retval = CALL_AreTexturesResident( GET_DISPATCH(), (
2749             n,
2750              (const GLuint *)(pc +  4),
2751             residences
2752         ) );
2753         __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
2754         error = Success;
2755     }
2756
2757     return error;
2758 }
2759
2760 int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
2761 {
2762     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
2763     int error;
2764     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2765
2766     pc += __GLX_VENDPRIV_HDR_SIZE;
2767     if ( cx != NULL ) {
2768         const GLsizei n = *(GLsizei  *)(pc +  0);
2769
2770         GLboolean retval;
2771         GLboolean answerBuffer[200];
2772         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
2773         retval = CALL_AreTexturesResident( GET_DISPATCH(), (
2774             n,
2775              (const GLuint *)(pc +  4),
2776             residences
2777         ) );
2778         __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
2779         error = Success;
2780     }
2781
2782     return error;
2783 }
2784
2785 void __glXDisp_CopyTexImage1D(GLbyte * pc)
2786 {
2787     CALL_CopyTexImage1D( GET_DISPATCH(), (
2788         *(GLenum   *)(pc +  0),
2789         *(GLint    *)(pc +  4),
2790         *(GLenum   *)(pc +  8),
2791         *(GLint    *)(pc + 12),
2792         *(GLint    *)(pc + 16),
2793         *(GLsizei  *)(pc + 20),
2794         *(GLint    *)(pc + 24)
2795     ) );
2796 }
2797
2798 void __glXDisp_CopyTexImage2D(GLbyte * pc)
2799 {
2800     CALL_CopyTexImage2D( GET_DISPATCH(), (
2801         *(GLenum   *)(pc +  0),
2802         *(GLint    *)(pc +  4),
2803         *(GLenum   *)(pc +  8),
2804         *(GLint    *)(pc + 12),
2805         *(GLint    *)(pc + 16),
2806         *(GLsizei  *)(pc + 20),
2807         *(GLsizei  *)(pc + 24),
2808         *(GLint    *)(pc + 28)
2809     ) );
2810 }
2811
2812 void __glXDisp_CopyTexSubImage1D(GLbyte * pc)
2813 {
2814     CALL_CopyTexSubImage1D( GET_DISPATCH(), (
2815         *(GLenum   *)(pc +  0),
2816         *(GLint    *)(pc +  4),
2817         *(GLint    *)(pc +  8),
2818         *(GLint    *)(pc + 12),
2819         *(GLint    *)(pc + 16),
2820         *(GLsizei  *)(pc + 20)
2821     ) );
2822 }
2823
2824 void __glXDisp_CopyTexSubImage2D(GLbyte * pc)
2825 {
2826     CALL_CopyTexSubImage2D( GET_DISPATCH(), (
2827         *(GLenum   *)(pc +  0),
2828         *(GLint    *)(pc +  4),
2829         *(GLint    *)(pc +  8),
2830         *(GLint    *)(pc + 12),
2831         *(GLint    *)(pc + 16),
2832         *(GLint    *)(pc + 20),
2833         *(GLsizei  *)(pc + 24),
2834         *(GLsizei  *)(pc + 28)
2835     ) );
2836 }
2837
2838 int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
2839 {
2840     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2841     int error;
2842     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2843
2844     pc += __GLX_SINGLE_HDR_SIZE;
2845     if ( cx != NULL ) {
2846         const GLsizei n = *(GLsizei  *)(pc +  0);
2847
2848         CALL_DeleteTextures( GET_DISPATCH(), (
2849             n,
2850              (const GLuint *)(pc +  4)
2851         ) );
2852         error = Success;
2853     }
2854
2855     return error;
2856 }
2857
2858 int __glXDisp_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc)
2859 {
2860     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
2861     int error;
2862     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2863
2864     pc += __GLX_VENDPRIV_HDR_SIZE;
2865     if ( cx != NULL ) {
2866         const GLsizei n = *(GLsizei  *)(pc +  0);
2867
2868         CALL_DeleteTextures( GET_DISPATCH(), (
2869             n,
2870              (const GLuint *)(pc +  4)
2871         ) );
2872         error = Success;
2873     }
2874
2875     return error;
2876 }
2877
2878 int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
2879 {
2880     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2881     int error;
2882     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2883
2884     pc += __GLX_SINGLE_HDR_SIZE;
2885     if ( cx != NULL ) {
2886         const GLsizei n = *(GLsizei  *)(pc +  0);
2887
2888         GLuint answerBuffer[200];
2889         GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
2890         CALL_GenTextures( GET_DISPATCH(), (
2891             n,
2892             textures
2893         ) );
2894         __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
2895         error = Success;
2896     }
2897
2898     return error;
2899 }
2900
2901 int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
2902 {
2903     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
2904     int error;
2905     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2906
2907     pc += __GLX_VENDPRIV_HDR_SIZE;
2908     if ( cx != NULL ) {
2909         const GLsizei n = *(GLsizei  *)(pc +  0);
2910
2911         GLuint answerBuffer[200];
2912         GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
2913         CALL_GenTextures( GET_DISPATCH(), (
2914             n,
2915             textures
2916         ) );
2917         __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
2918         error = Success;
2919     }
2920
2921     return error;
2922 }
2923
2924 int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc)
2925 {
2926     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
2927     int error;
2928     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2929
2930     pc += __GLX_SINGLE_HDR_SIZE;
2931     if ( cx != NULL ) {
2932         GLboolean retval;
2933         retval = CALL_IsTexture( GET_DISPATCH(), (
2934             *(GLuint   *)(pc +  0)
2935         ) );
2936         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2937         error = Success;
2938     }
2939
2940     return error;
2941 }
2942
2943 int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
2944 {
2945     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
2946     int error;
2947     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
2948
2949     pc += __GLX_VENDPRIV_HDR_SIZE;
2950     if ( cx != NULL ) {
2951         GLboolean retval;
2952         retval = CALL_IsTexture( GET_DISPATCH(), (
2953             *(GLuint   *)(pc +  0)
2954         ) );
2955         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2956         error = Success;
2957     }
2958
2959     return error;
2960 }
2961
2962 void __glXDisp_PrioritizeTextures(GLbyte * pc)
2963 {
2964     const GLsizei n = *(GLsizei  *)(pc +  0);
2965
2966     CALL_PrioritizeTextures( GET_DISPATCH(), (
2967         n,
2968          (const GLuint *)(pc +  4),
2969          (const GLclampf *)(pc +  4)
2970     ) );
2971 }
2972
2973 void __glXDisp_TexSubImage1D(GLbyte * pc)
2974 {
2975     const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
2976     const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
2977     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
2978
2979     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
2980     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
2981     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
2982     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
2983     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
2984     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
2985
2986     CALL_TexSubImage1D( GET_DISPATCH(), (
2987         *(GLenum   *)(pc + 20),
2988         *(GLint    *)(pc + 24),
2989         *(GLint    *)(pc + 28),
2990         *(GLsizei  *)(pc + 36),
2991         *(GLenum   *)(pc + 44),
2992         *(GLenum   *)(pc + 48),
2993         pixels
2994     ) );
2995 }
2996
2997 void __glXDisp_TexSubImage2D(GLbyte * pc)
2998 {
2999     const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
3000     const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
3001     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
3002
3003     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3004     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3005     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3006     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3007     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3008     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3009
3010     CALL_TexSubImage2D( GET_DISPATCH(), (
3011         *(GLenum   *)(pc + 20),
3012         *(GLint    *)(pc + 24),
3013         *(GLint    *)(pc + 28),
3014         *(GLint    *)(pc + 32),
3015         *(GLsizei  *)(pc + 36),
3016         *(GLsizei  *)(pc + 40),
3017         *(GLenum   *)(pc + 44),
3018         *(GLenum   *)(pc + 48),
3019         pixels
3020     ) );
3021 }
3022
3023 void __glXDisp_BlendColor(GLbyte * pc)
3024 {
3025     CALL_BlendColor( GET_DISPATCH(), (
3026         *(GLclampf *)(pc +  0),
3027         *(GLclampf *)(pc +  4),
3028         *(GLclampf *)(pc +  8),
3029         *(GLclampf *)(pc + 12)
3030     ) );
3031 }
3032
3033 void __glXDisp_BlendEquation(GLbyte * pc)
3034 {
3035     CALL_BlendEquation( GET_DISPATCH(), (
3036         *(GLenum   *)(pc +  0)
3037     ) );
3038 }
3039
3040 void __glXDisp_ColorTable(GLbyte * pc)
3041 {
3042     const GLvoid * const table = (const GLvoid *) (pc + 40);
3043     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
3044
3045     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3046     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3047     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3048     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3049     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3050     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3051
3052     CALL_ColorTable( GET_DISPATCH(), (
3053         *(GLenum   *)(pc + 20),
3054         *(GLenum   *)(pc + 24),
3055         *(GLsizei  *)(pc + 28),
3056         *(GLenum   *)(pc + 32),
3057         *(GLenum   *)(pc + 36),
3058         table
3059     ) );
3060 }
3061
3062 void __glXDisp_ColorTableParameterfv(GLbyte * pc)
3063 {
3064     const GLenum pname = *(GLenum   *)(pc +  4);
3065     const GLfloat * params;
3066
3067     params = (const GLfloat *) (pc + 8);
3068
3069     CALL_ColorTableParameterfv( GET_DISPATCH(), (
3070         *(GLenum   *)(pc +  0),
3071         pname,
3072         params
3073     ) );
3074 }
3075
3076 void __glXDisp_ColorTableParameteriv(GLbyte * pc)
3077 {
3078     const GLenum pname = *(GLenum   *)(pc +  4);
3079     const GLint * params;
3080
3081     params = (const GLint *) (pc + 8);
3082
3083     CALL_ColorTableParameteriv( GET_DISPATCH(), (
3084         *(GLenum   *)(pc +  0),
3085         pname,
3086         params
3087     ) );
3088 }
3089
3090 void __glXDisp_CopyColorTable(GLbyte * pc)
3091 {
3092     CALL_CopyColorTable( GET_DISPATCH(), (
3093         *(GLenum   *)(pc +  0),
3094         *(GLenum   *)(pc +  4),
3095         *(GLint    *)(pc +  8),
3096         *(GLint    *)(pc + 12),
3097         *(GLsizei  *)(pc + 16)
3098     ) );
3099 }
3100
3101 int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
3102 {
3103     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3104     int error;
3105     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3106
3107     pc += __GLX_SINGLE_HDR_SIZE;
3108     if ( cx != NULL ) {
3109         const GLenum pname = *(GLenum   *)(pc +  4);
3110
3111         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
3112         GLfloat answerBuffer[200];
3113         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3114
3115         if (params == NULL) return BadAlloc;
3116         __glXClearErrorOccured();
3117
3118         CALL_GetColorTableParameterfv( GET_DISPATCH(), (
3119             *(GLenum   *)(pc +  0),
3120             pname,
3121             params
3122         ) );
3123         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3124         error = Success;
3125     }
3126
3127     return error;
3128 }
3129
3130 int __glXDisp_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc)
3131 {
3132     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3133     int error;
3134     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3135
3136     pc += __GLX_VENDPRIV_HDR_SIZE;
3137     if ( cx != NULL ) {
3138         const GLenum pname = *(GLenum   *)(pc +  4);
3139
3140         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
3141         GLfloat answerBuffer[200];
3142         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3143
3144         if (params == NULL) return BadAlloc;
3145         __glXClearErrorOccured();
3146
3147         CALL_GetColorTableParameterfv( GET_DISPATCH(), (
3148             *(GLenum   *)(pc +  0),
3149             pname,
3150             params
3151         ) );
3152         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3153         error = Success;
3154     }
3155
3156     return error;
3157 }
3158
3159 int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
3160 {
3161     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3162     int error;
3163     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3164
3165     pc += __GLX_SINGLE_HDR_SIZE;
3166     if ( cx != NULL ) {
3167         const GLenum pname = *(GLenum   *)(pc +  4);
3168
3169         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
3170         GLint answerBuffer[200];
3171         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3172
3173         if (params == NULL) return BadAlloc;
3174         __glXClearErrorOccured();
3175
3176         CALL_GetColorTableParameteriv( GET_DISPATCH(), (
3177             *(GLenum   *)(pc +  0),
3178             pname,
3179             params
3180         ) );
3181         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3182         error = Success;
3183     }
3184
3185     return error;
3186 }
3187
3188 int __glXDisp_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
3189 {
3190     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3191     int error;
3192     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3193
3194     pc += __GLX_VENDPRIV_HDR_SIZE;
3195     if ( cx != NULL ) {
3196         const GLenum pname = *(GLenum   *)(pc +  4);
3197
3198         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
3199         GLint answerBuffer[200];
3200         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3201
3202         if (params == NULL) return BadAlloc;
3203         __glXClearErrorOccured();
3204
3205         CALL_GetColorTableParameteriv( GET_DISPATCH(), (
3206             *(GLenum   *)(pc +  0),
3207             pname,
3208             params
3209         ) );
3210         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3211         error = Success;
3212     }
3213
3214     return error;
3215 }
3216
3217 void __glXDisp_ColorSubTable(GLbyte * pc)
3218 {
3219     const GLvoid * const data = (const GLvoid *) (pc + 40);
3220     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
3221
3222     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3223     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3224     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3225     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3226     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3227     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3228
3229     CALL_ColorSubTable( GET_DISPATCH(), (
3230         *(GLenum   *)(pc + 20),
3231         *(GLsizei  *)(pc + 24),
3232         *(GLsizei  *)(pc + 28),
3233         *(GLenum   *)(pc + 32),
3234         *(GLenum   *)(pc + 36),
3235         data
3236     ) );
3237 }
3238
3239 void __glXDisp_CopyColorSubTable(GLbyte * pc)
3240 {
3241     CALL_CopyColorSubTable( GET_DISPATCH(), (
3242         *(GLenum   *)(pc +  0),
3243         *(GLsizei  *)(pc +  4),
3244         *(GLint    *)(pc +  8),
3245         *(GLint    *)(pc + 12),
3246         *(GLsizei  *)(pc + 16)
3247     ) );
3248 }
3249
3250 void __glXDisp_ConvolutionFilter1D(GLbyte * pc)
3251 {
3252     const GLvoid * const image = (const GLvoid *) (pc + 44);
3253     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
3254
3255     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3256     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3257     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3258     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3259     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3260     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3261
3262     CALL_ConvolutionFilter1D( GET_DISPATCH(), (
3263         *(GLenum   *)(pc + 20),
3264         *(GLenum   *)(pc + 24),
3265         *(GLsizei  *)(pc + 28),
3266         *(GLenum   *)(pc + 36),
3267         *(GLenum   *)(pc + 40),
3268         image
3269     ) );
3270 }
3271
3272 void __glXDisp_ConvolutionFilter2D(GLbyte * pc)
3273 {
3274     const GLvoid * const image = (const GLvoid *) (pc + 44);
3275     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
3276
3277     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3278     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3279     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3280     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3281     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3282     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3283
3284     CALL_ConvolutionFilter2D( GET_DISPATCH(), (
3285         *(GLenum   *)(pc + 20),
3286         *(GLenum   *)(pc + 24),
3287         *(GLsizei  *)(pc + 28),
3288         *(GLsizei  *)(pc + 32),
3289         *(GLenum   *)(pc + 36),
3290         *(GLenum   *)(pc + 40),
3291         image
3292     ) );
3293 }
3294
3295 void __glXDisp_ConvolutionParameterf(GLbyte * pc)
3296 {
3297     CALL_ConvolutionParameterf( GET_DISPATCH(), (
3298         *(GLenum   *)(pc +  0),
3299         *(GLenum   *)(pc +  4),
3300         *(GLfloat  *)(pc +  8)
3301     ) );
3302 }
3303
3304 void __glXDisp_ConvolutionParameterfv(GLbyte * pc)
3305 {
3306     const GLenum pname = *(GLenum   *)(pc +  4);
3307     const GLfloat * params;
3308
3309     params = (const GLfloat *) (pc + 8);
3310
3311     CALL_ConvolutionParameterfv( GET_DISPATCH(), (
3312         *(GLenum   *)(pc +  0),
3313         pname,
3314         params
3315     ) );
3316 }
3317
3318 void __glXDisp_ConvolutionParameteri(GLbyte * pc)
3319 {
3320     CALL_ConvolutionParameteri( GET_DISPATCH(), (
3321         *(GLenum   *)(pc +  0),
3322         *(GLenum   *)(pc +  4),
3323         *(GLint    *)(pc +  8)
3324     ) );
3325 }
3326
3327 void __glXDisp_ConvolutionParameteriv(GLbyte * pc)
3328 {
3329     const GLenum pname = *(GLenum   *)(pc +  4);
3330     const GLint * params;
3331
3332     params = (const GLint *) (pc + 8);
3333
3334     CALL_ConvolutionParameteriv( GET_DISPATCH(), (
3335         *(GLenum   *)(pc +  0),
3336         pname,
3337         params
3338     ) );
3339 }
3340
3341 void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
3342 {
3343     CALL_CopyConvolutionFilter1D( GET_DISPATCH(), (
3344         *(GLenum   *)(pc +  0),
3345         *(GLenum   *)(pc +  4),
3346         *(GLint    *)(pc +  8),
3347         *(GLint    *)(pc + 12),
3348         *(GLsizei  *)(pc + 16)
3349     ) );
3350 }
3351
3352 void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
3353 {
3354     CALL_CopyConvolutionFilter2D( GET_DISPATCH(), (
3355         *(GLenum   *)(pc +  0),
3356         *(GLenum   *)(pc +  4),
3357         *(GLint    *)(pc +  8),
3358         *(GLint    *)(pc + 12),
3359         *(GLsizei  *)(pc + 16),
3360         *(GLsizei  *)(pc + 20)
3361     ) );
3362 }
3363
3364 int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
3365 {
3366     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3367     int error;
3368     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3369
3370     pc += __GLX_SINGLE_HDR_SIZE;
3371     if ( cx != NULL ) {
3372         const GLenum pname = *(GLenum   *)(pc +  4);
3373
3374         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
3375         GLfloat answerBuffer[200];
3376         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3377
3378         if (params == NULL) return BadAlloc;
3379         __glXClearErrorOccured();
3380
3381         CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
3382             *(GLenum   *)(pc +  0),
3383             pname,
3384             params
3385         ) );
3386         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3387         error = Success;
3388     }
3389
3390     return error;
3391 }
3392
3393 int __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
3394 {
3395     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3396     int error;
3397     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3398
3399     pc += __GLX_VENDPRIV_HDR_SIZE;
3400     if ( cx != NULL ) {
3401         const GLenum pname = *(GLenum   *)(pc +  4);
3402
3403         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
3404         GLfloat answerBuffer[200];
3405         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3406
3407         if (params == NULL) return BadAlloc;
3408         __glXClearErrorOccured();
3409
3410         CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
3411             *(GLenum   *)(pc +  0),
3412             pname,
3413             params
3414         ) );
3415         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3416         error = Success;
3417     }
3418
3419     return error;
3420 }
3421
3422 int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
3423 {
3424     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3425     int error;
3426     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3427
3428     pc += __GLX_SINGLE_HDR_SIZE;
3429     if ( cx != NULL ) {
3430         const GLenum pname = *(GLenum   *)(pc +  4);
3431
3432         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
3433         GLint answerBuffer[200];
3434         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3435
3436         if (params == NULL) return BadAlloc;
3437         __glXClearErrorOccured();
3438
3439         CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
3440             *(GLenum   *)(pc +  0),
3441             pname,
3442             params
3443         ) );
3444         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3445         error = Success;
3446     }
3447
3448     return error;
3449 }
3450
3451 int __glXDisp_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc)
3452 {
3453     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3454     int error;
3455     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3456
3457     pc += __GLX_VENDPRIV_HDR_SIZE;
3458     if ( cx != NULL ) {
3459         const GLenum pname = *(GLenum   *)(pc +  4);
3460
3461         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
3462         GLint answerBuffer[200];
3463         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3464
3465         if (params == NULL) return BadAlloc;
3466         __glXClearErrorOccured();
3467
3468         CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
3469             *(GLenum   *)(pc +  0),
3470             pname,
3471             params
3472         ) );
3473         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3474         error = Success;
3475     }
3476
3477     return error;
3478 }
3479
3480 int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
3481 {
3482     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3483     int error;
3484     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3485
3486     pc += __GLX_SINGLE_HDR_SIZE;
3487     if ( cx != NULL ) {
3488         const GLenum pname = *(GLenum   *)(pc +  4);
3489
3490         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
3491         GLfloat answerBuffer[200];
3492         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3493
3494         if (params == NULL) return BadAlloc;
3495         __glXClearErrorOccured();
3496
3497         CALL_GetHistogramParameterfv( GET_DISPATCH(), (
3498             *(GLenum   *)(pc +  0),
3499             pname,
3500             params
3501         ) );
3502         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3503         error = Success;
3504     }
3505
3506     return error;
3507 }
3508
3509 int __glXDisp_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
3510 {
3511     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3512     int error;
3513     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3514
3515     pc += __GLX_VENDPRIV_HDR_SIZE;
3516     if ( cx != NULL ) {
3517         const GLenum pname = *(GLenum   *)(pc +  4);
3518
3519         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
3520         GLfloat answerBuffer[200];
3521         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3522
3523         if (params == NULL) return BadAlloc;
3524         __glXClearErrorOccured();
3525
3526         CALL_GetHistogramParameterfv( GET_DISPATCH(), (
3527             *(GLenum   *)(pc +  0),
3528             pname,
3529             params
3530         ) );
3531         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3532         error = Success;
3533     }
3534
3535     return error;
3536 }
3537
3538 int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
3539 {
3540     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3541     int error;
3542     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3543
3544     pc += __GLX_SINGLE_HDR_SIZE;
3545     if ( cx != NULL ) {
3546         const GLenum pname = *(GLenum   *)(pc +  4);
3547
3548         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
3549         GLint answerBuffer[200];
3550         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3551
3552         if (params == NULL) return BadAlloc;
3553         __glXClearErrorOccured();
3554
3555         CALL_GetHistogramParameteriv( GET_DISPATCH(), (
3556             *(GLenum   *)(pc +  0),
3557             pname,
3558             params
3559         ) );
3560         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3561         error = Success;
3562     }
3563
3564     return error;
3565 }
3566
3567 int __glXDisp_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc)
3568 {
3569     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3570     int error;
3571     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3572
3573     pc += __GLX_VENDPRIV_HDR_SIZE;
3574     if ( cx != NULL ) {
3575         const GLenum pname = *(GLenum   *)(pc +  4);
3576
3577         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
3578         GLint answerBuffer[200];
3579         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3580
3581         if (params == NULL) return BadAlloc;
3582         __glXClearErrorOccured();
3583
3584         CALL_GetHistogramParameteriv( GET_DISPATCH(), (
3585             *(GLenum   *)(pc +  0),
3586             pname,
3587             params
3588         ) );
3589         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3590         error = Success;
3591     }
3592
3593     return error;
3594 }
3595
3596 int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
3597 {
3598     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3599     int error;
3600     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3601
3602     pc += __GLX_SINGLE_HDR_SIZE;
3603     if ( cx != NULL ) {
3604         const GLenum pname = *(GLenum   *)(pc +  4);
3605
3606         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
3607         GLfloat answerBuffer[200];
3608         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3609
3610         if (params == NULL) return BadAlloc;
3611         __glXClearErrorOccured();
3612
3613         CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
3614             *(GLenum   *)(pc +  0),
3615             pname,
3616             params
3617         ) );
3618         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3619         error = Success;
3620     }
3621
3622     return error;
3623 }
3624
3625 int __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
3626 {
3627     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3628     int error;
3629     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3630
3631     pc += __GLX_VENDPRIV_HDR_SIZE;
3632     if ( cx != NULL ) {
3633         const GLenum pname = *(GLenum   *)(pc +  4);
3634
3635         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
3636         GLfloat answerBuffer[200];
3637         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3638
3639         if (params == NULL) return BadAlloc;
3640         __glXClearErrorOccured();
3641
3642         CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
3643             *(GLenum   *)(pc +  0),
3644             pname,
3645             params
3646         ) );
3647         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3648         error = Success;
3649     }
3650
3651     return error;
3652 }
3653
3654 int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
3655 {
3656     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
3657     int error;
3658     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3659
3660     pc += __GLX_SINGLE_HDR_SIZE;
3661     if ( cx != NULL ) {
3662         const GLenum pname = *(GLenum   *)(pc +  4);
3663
3664         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
3665         GLint answerBuffer[200];
3666         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3667
3668         if (params == NULL) return BadAlloc;
3669         __glXClearErrorOccured();
3670
3671         CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
3672             *(GLenum   *)(pc +  0),
3673             pname,
3674             params
3675         ) );
3676         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3677         error = Success;
3678     }
3679
3680     return error;
3681 }
3682
3683 int __glXDisp_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc)
3684 {
3685     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
3686     int error;
3687     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
3688
3689     pc += __GLX_VENDPRIV_HDR_SIZE;
3690     if ( cx != NULL ) {
3691         const GLenum pname = *(GLenum   *)(pc +  4);
3692
3693         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
3694         GLint answerBuffer[200];
3695         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
3696
3697         if (params == NULL) return BadAlloc;
3698         __glXClearErrorOccured();
3699
3700         CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
3701             *(GLenum   *)(pc +  0),
3702             pname,
3703             params
3704         ) );
3705         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
3706         error = Success;
3707     }
3708
3709     return error;
3710 }
3711
3712 void __glXDisp_Histogram(GLbyte * pc)
3713 {
3714     CALL_Histogram( GET_DISPATCH(), (
3715         *(GLenum   *)(pc +  0),
3716         *(GLsizei  *)(pc +  4),
3717         *(GLenum   *)(pc +  8),
3718         *(GLboolean *)(pc + 12)
3719     ) );
3720 }
3721
3722 void __glXDisp_Minmax(GLbyte * pc)
3723 {
3724     CALL_Minmax( GET_DISPATCH(), (
3725         *(GLenum   *)(pc +  0),
3726         *(GLenum   *)(pc +  4),
3727         *(GLboolean *)(pc +  8)
3728     ) );
3729 }
3730
3731 void __glXDisp_ResetHistogram(GLbyte * pc)
3732 {
3733     CALL_ResetHistogram( GET_DISPATCH(), (
3734         *(GLenum   *)(pc +  0)
3735     ) );
3736 }
3737
3738 void __glXDisp_ResetMinmax(GLbyte * pc)
3739 {
3740     CALL_ResetMinmax( GET_DISPATCH(), (
3741         *(GLenum   *)(pc +  0)
3742     ) );
3743 }
3744
3745 void __glXDisp_TexImage3D(GLbyte * pc)
3746 {
3747     const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
3748     const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 80);
3749     __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
3750
3751     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3752     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3753     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3754     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) );
3755     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3756     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages) );
3757     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3758     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3759
3760     CALL_TexImage3D( GET_DISPATCH(), (
3761         *(GLenum   *)(pc + 36),
3762         *(GLint    *)(pc + 40),
3763         *(GLint    *)(pc + 44),
3764         *(GLsizei  *)(pc + 48),
3765         *(GLsizei  *)(pc + 52),
3766         *(GLsizei  *)(pc + 56),
3767         *(GLint    *)(pc + 64),
3768         *(GLenum   *)(pc + 68),
3769         *(GLenum   *)(pc + 72),
3770         pixels
3771     ) );
3772 }
3773
3774 void __glXDisp_TexSubImage3D(GLbyte * pc)
3775 {
3776     const CARD32 ptr_is_null = *(CARD32 *)(pc + 84);
3777     const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 88);
3778     __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
3779
3780     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
3781     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
3782     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
3783     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) );
3784     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
3785     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages) );
3786     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
3787     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
3788
3789     CALL_TexSubImage3D( GET_DISPATCH(), (
3790         *(GLenum   *)(pc + 36),
3791         *(GLint    *)(pc + 40),
3792         *(GLint    *)(pc + 44),
3793         *(GLint    *)(pc + 48),
3794         *(GLint    *)(pc + 52),
3795         *(GLsizei  *)(pc + 60),
3796         *(GLsizei  *)(pc + 64),
3797         *(GLsizei  *)(pc + 68),
3798         *(GLenum   *)(pc + 76),
3799         *(GLenum   *)(pc + 80),
3800         pixels
3801     ) );
3802 }
3803
3804 void __glXDisp_CopyTexSubImage3D(GLbyte * pc)
3805 {
3806     CALL_CopyTexSubImage3D( GET_DISPATCH(), (
3807         *(GLenum   *)(pc +  0),
3808         *(GLint    *)(pc +  4),
3809         *(GLint    *)(pc +  8),
3810         *(GLint    *)(pc + 12),
3811         *(GLint    *)(pc + 16),
3812         *(GLint    *)(pc + 20),
3813         *(GLint    *)(pc + 24),
3814         *(GLsizei  *)(pc + 28),
3815         *(GLsizei  *)(pc + 32)
3816     ) );
3817 }
3818
3819 void __glXDisp_ActiveTextureARB(GLbyte * pc)
3820 {
3821     CALL_ActiveTextureARB( GET_DISPATCH(), (
3822         *(GLenum   *)(pc +  0)
3823     ) );
3824 }
3825
3826 void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc)
3827 {
3828 #ifdef __GLX_ALIGN64
3829     if ((unsigned long)(pc) & 7) {
3830         (void) memmove(pc-4, pc, 12);
3831         pc -= 4;
3832     }
3833 #endif
3834
3835     CALL_MultiTexCoord1dvARB( GET_DISPATCH(), (
3836         *(GLenum   *)(pc +  8),
3837          (const GLdouble *)(pc +  0)
3838     ) );
3839 }
3840
3841 void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
3842 {
3843     CALL_MultiTexCoord1fvARB( GET_DISPATCH(), (
3844         *(GLenum   *)(pc +  0),
3845          (const GLfloat *)(pc +  4)
3846     ) );
3847 }
3848
3849 void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc)
3850 {
3851     CALL_MultiTexCoord1ivARB( GET_DISPATCH(), (
3852         *(GLenum   *)(pc +  0),
3853          (const GLint *)(pc +  4)
3854     ) );
3855 }
3856
3857 void __glXDisp_MultiTexCoord1svARB(GLbyte * pc)
3858 {
3859     CALL_MultiTexCoord1svARB( GET_DISPATCH(), (
3860         *(GLenum   *)(pc +  0),
3861          (const GLshort *)(pc +  4)
3862     ) );
3863 }
3864
3865 void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc)
3866 {
3867 #ifdef __GLX_ALIGN64
3868     if ((unsigned long)(pc) & 7) {
3869         (void) memmove(pc-4, pc, 20);
3870         pc -= 4;
3871     }
3872 #endif
3873
3874     CALL_MultiTexCoord2dvARB( GET_DISPATCH(), (
3875         *(GLenum   *)(pc + 16),
3876          (const GLdouble *)(pc +  0)
3877     ) );
3878 }
3879
3880 void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
3881 {
3882     CALL_MultiTexCoord2fvARB( GET_DISPATCH(), (
3883         *(GLenum   *)(pc +  0),
3884          (const GLfloat *)(pc +  4)
3885     ) );
3886 }
3887
3888 void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc)
3889 {
3890     CALL_MultiTexCoord2ivARB( GET_DISPATCH(), (
3891         *(GLenum   *)(pc +  0),
3892          (const GLint *)(pc +  4)
3893     ) );
3894 }
3895
3896 void __glXDisp_MultiTexCoord2svARB(GLbyte * pc)
3897 {
3898     CALL_MultiTexCoord2svARB( GET_DISPATCH(), (
3899         *(GLenum   *)(pc +  0),
3900          (const GLshort *)(pc +  4)
3901     ) );
3902 }
3903
3904 void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc)
3905 {
3906 #ifdef __GLX_ALIGN64
3907     if ((unsigned long)(pc) & 7) {
3908         (void) memmove(pc-4, pc, 28);
3909         pc -= 4;
3910     }
3911 #endif
3912
3913     CALL_MultiTexCoord3dvARB( GET_DISPATCH(), (
3914         *(GLenum   *)(pc + 24),
3915          (const GLdouble *)(pc +  0)
3916     ) );
3917 }
3918
3919 void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
3920 {
3921     CALL_MultiTexCoord3fvARB( GET_DISPATCH(), (
3922         *(GLenum   *)(pc +  0),
3923          (const GLfloat *)(pc +  4)
3924     ) );
3925 }
3926
3927 void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc)
3928 {
3929     CALL_MultiTexCoord3ivARB( GET_DISPATCH(), (
3930         *(GLenum   *)(pc +  0),
3931          (const GLint *)(pc +  4)
3932     ) );
3933 }
3934
3935 void __glXDisp_MultiTexCoord3svARB(GLbyte * pc)
3936 {
3937     CALL_MultiTexCoord3svARB( GET_DISPATCH(), (
3938         *(GLenum   *)(pc +  0),
3939          (const GLshort *)(pc +  4)
3940     ) );
3941 }
3942
3943 void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc)
3944 {
3945 #ifdef __GLX_ALIGN64
3946     if ((unsigned long)(pc) & 7) {
3947         (void) memmove(pc-4, pc, 36);
3948         pc -= 4;
3949     }
3950 #endif
3951
3952     CALL_MultiTexCoord4dvARB( GET_DISPATCH(), (
3953         *(GLenum   *)(pc + 32),
3954          (const GLdouble *)(pc +  0)
3955     ) );
3956 }
3957
3958 void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
3959 {
3960     CALL_MultiTexCoord4fvARB( GET_DISPATCH(), (
3961         *(GLenum   *)(pc +  0),
3962          (const GLfloat *)(pc +  4)
3963     ) );
3964 }
3965
3966 void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc)
3967 {
3968     CALL_MultiTexCoord4ivARB( GET_DISPATCH(), (
3969         *(GLenum   *)(pc +  0),
3970          (const GLint *)(pc +  4)
3971     ) );
3972 }
3973
3974 void __glXDisp_MultiTexCoord4svARB(GLbyte * pc)
3975 {
3976     CALL_MultiTexCoord4svARB( GET_DISPATCH(), (
3977         *(GLenum   *)(pc +  0),
3978          (const GLshort *)(pc +  4)
3979     ) );
3980 }
3981
3982 void __glXDisp_SampleCoverageARB(GLbyte * pc)
3983 {
3984     CALL_SampleCoverageARB( GET_DISPATCH(), (
3985         *(GLclampf *)(pc +  0),
3986         *(GLboolean *)(pc +  4)
3987     ) );
3988 }
3989
3990 void __glXDisp_CompressedTexImage1DARB(GLbyte * pc)
3991 {
3992     const GLsizei imageSize = *(GLsizei  *)(pc + 20);
3993
3994     CALL_CompressedTexImage1DARB( GET_DISPATCH(), (
3995         *(GLenum   *)(pc +  0),
3996         *(GLint    *)(pc +  4),
3997         *(GLenum   *)(pc +  8),
3998         *(GLsizei  *)(pc + 12),
3999         *(GLint    *)(pc + 16),
4000         imageSize,
4001          (const GLvoid *)(pc + 24)
4002     ) );
4003 }
4004
4005 void __glXDisp_CompressedTexImage2DARB(GLbyte * pc)
4006 {
4007     const GLsizei imageSize = *(GLsizei  *)(pc + 24);
4008
4009     CALL_CompressedTexImage2DARB( GET_DISPATCH(), (
4010         *(GLenum   *)(pc +  0),
4011         *(GLint    *)(pc +  4),
4012         *(GLenum   *)(pc +  8),
4013         *(GLsizei  *)(pc + 12),
4014         *(GLsizei  *)(pc + 16),
4015         *(GLint    *)(pc + 20),
4016         imageSize,
4017          (const GLvoid *)(pc + 28)
4018     ) );
4019 }
4020
4021 void __glXDisp_CompressedTexImage3DARB(GLbyte * pc)
4022 {
4023     const GLsizei imageSize = *(GLsizei  *)(pc + 28);
4024
4025     CALL_CompressedTexImage3DARB( GET_DISPATCH(), (
4026         *(GLenum   *)(pc +  0),
4027         *(GLint    *)(pc +  4),
4028         *(GLenum   *)(pc +  8),
4029         *(GLsizei  *)(pc + 12),
4030         *(GLsizei  *)(pc + 16),
4031         *(GLsizei  *)(pc + 20),
4032         *(GLint    *)(pc + 24),
4033         imageSize,
4034          (const GLvoid *)(pc + 32)
4035     ) );
4036 }
4037
4038 void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc)
4039 {
4040     const GLsizei imageSize = *(GLsizei  *)(pc + 20);
4041
4042     CALL_CompressedTexSubImage1DARB( GET_DISPATCH(), (
4043         *(GLenum   *)(pc +  0),
4044         *(GLint    *)(pc +  4),
4045         *(GLint    *)(pc +  8),
4046         *(GLsizei  *)(pc + 12),
4047         *(GLenum   *)(pc + 16),
4048         imageSize,
4049          (const GLvoid *)(pc + 24)
4050     ) );
4051 }
4052
4053 void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc)
4054 {
4055     const GLsizei imageSize = *(GLsizei  *)(pc + 28);
4056
4057     CALL_CompressedTexSubImage2DARB( GET_DISPATCH(), (
4058         *(GLenum   *)(pc +  0),
4059         *(GLint    *)(pc +  4),
4060         *(GLint    *)(pc +  8),
4061         *(GLint    *)(pc + 12),
4062         *(GLsizei  *)(pc + 16),
4063         *(GLsizei  *)(pc + 20),
4064         *(GLenum   *)(pc + 24),
4065         imageSize,
4066          (const GLvoid *)(pc + 32)
4067     ) );
4068 }
4069
4070 void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc)
4071 {
4072     const GLsizei imageSize = *(GLsizei  *)(pc + 36);
4073
4074     CALL_CompressedTexSubImage3DARB( GET_DISPATCH(), (
4075         *(GLenum   *)(pc +  0),
4076         *(GLint    *)(pc +  4),
4077         *(GLint    *)(pc +  8),
4078         *(GLint    *)(pc + 12),
4079         *(GLint    *)(pc + 16),
4080         *(GLsizei  *)(pc + 20),
4081         *(GLsizei  *)(pc + 24),
4082         *(GLsizei  *)(pc + 28),
4083         *(GLenum   *)(pc + 32),
4084         imageSize,
4085          (const GLvoid *)(pc + 40)
4086     ) );
4087 }
4088
4089 int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
4090 {
4091     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4092     int error;
4093     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4094
4095     pc += __GLX_VENDPRIV_HDR_SIZE;
4096     if ( cx != NULL ) {
4097         GLdouble params[4];
4098         CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), (
4099             *(GLenum   *)(pc +  0),
4100             *(GLuint   *)(pc +  4),
4101             params
4102         ) );
4103         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
4104         error = Success;
4105     }
4106
4107     return error;
4108 }
4109
4110 int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
4111 {
4112     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4113     int error;
4114     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4115
4116     pc += __GLX_VENDPRIV_HDR_SIZE;
4117     if ( cx != NULL ) {
4118         GLfloat params[4];
4119         CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), (
4120             *(GLenum   *)(pc +  0),
4121             *(GLuint   *)(pc +  4),
4122             params
4123         ) );
4124         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
4125         error = Success;
4126     }
4127
4128     return error;
4129 }
4130
4131 int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
4132 {
4133     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4134     int error;
4135     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4136
4137     pc += __GLX_VENDPRIV_HDR_SIZE;
4138     if ( cx != NULL ) {
4139         GLdouble params[4];
4140         CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), (
4141             *(GLenum   *)(pc +  0),
4142             *(GLuint   *)(pc +  4),
4143             params
4144         ) );
4145         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
4146         error = Success;
4147     }
4148
4149     return error;
4150 }
4151
4152 int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
4153 {
4154     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4155     int error;
4156     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4157
4158     pc += __GLX_VENDPRIV_HDR_SIZE;
4159     if ( cx != NULL ) {
4160         GLfloat params[4];
4161         CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), (
4162             *(GLenum   *)(pc +  0),
4163             *(GLuint   *)(pc +  4),
4164             params
4165         ) );
4166         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
4167         error = Success;
4168     }
4169
4170     return error;
4171 }
4172
4173 int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
4174 {
4175     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4176     int error;
4177     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4178
4179     pc += __GLX_VENDPRIV_HDR_SIZE;
4180     if ( cx != NULL ) {
4181         const GLenum pname = *(GLenum   *)(pc +  4);
4182
4183         const GLuint compsize = __glGetProgramivARB_size(pname);
4184         GLint answerBuffer[200];
4185         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
4186
4187         if (params == NULL) return BadAlloc;
4188         __glXClearErrorOccured();
4189
4190         CALL_GetProgramivARB( GET_DISPATCH(), (
4191             *(GLenum   *)(pc +  0),
4192             pname,
4193             params
4194         ) );
4195         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
4196         error = Success;
4197     }
4198
4199     return error;
4200 }
4201
4202 int __glXDisp_GetVertexAttribdvARB(__GLXclientState *cl, GLbyte *pc)
4203 {
4204     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4205     int error;
4206     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4207
4208     pc += __GLX_VENDPRIV_HDR_SIZE;
4209     if ( cx != NULL ) {
4210         const GLenum pname = *(GLenum   *)(pc +  4);
4211
4212         const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
4213         GLdouble answerBuffer[200];
4214         GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
4215
4216         if (params == NULL) return BadAlloc;
4217         __glXClearErrorOccured();
4218
4219         CALL_GetVertexAttribdvARB( GET_DISPATCH(), (
4220             *(GLuint   *)(pc +  0),
4221             pname,
4222             params
4223         ) );
4224         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
4225         error = Success;
4226     }
4227
4228     return error;
4229 }
4230
4231 int __glXDisp_GetVertexAttribfvARB(__GLXclientState *cl, GLbyte *pc)
4232 {
4233     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4234     int error;
4235     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4236
4237     pc += __GLX_VENDPRIV_HDR_SIZE;
4238     if ( cx != NULL ) {
4239         const GLenum pname = *(GLenum   *)(pc +  4);
4240
4241         const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
4242         GLfloat answerBuffer[200];
4243         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
4244
4245         if (params == NULL) return BadAlloc;
4246         __glXClearErrorOccured();
4247
4248         CALL_GetVertexAttribfvARB( GET_DISPATCH(), (
4249             *(GLuint   *)(pc +  0),
4250             pname,
4251             params
4252         ) );
4253         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
4254         error = Success;
4255     }
4256
4257     return error;
4258 }
4259
4260 int __glXDisp_GetVertexAttribivARB(__GLXclientState *cl, GLbyte *pc)
4261 {
4262     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4263     int error;
4264     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4265
4266     pc += __GLX_VENDPRIV_HDR_SIZE;
4267     if ( cx != NULL ) {
4268         const GLenum pname = *(GLenum   *)(pc +  4);
4269
4270         const GLuint compsize = __glGetVertexAttribivARB_size(pname);
4271         GLint answerBuffer[200];
4272         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
4273
4274         if (params == NULL) return BadAlloc;
4275         __glXClearErrorOccured();
4276
4277         CALL_GetVertexAttribivARB( GET_DISPATCH(), (
4278             *(GLuint   *)(pc +  0),
4279             pname,
4280             params
4281         ) );
4282         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
4283         error = Success;
4284     }
4285
4286     return error;
4287 }
4288
4289 void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
4290 {
4291 #ifdef __GLX_ALIGN64
4292     if ((unsigned long)(pc) & 7) {
4293         (void) memmove(pc-4, pc, 40);
4294         pc -= 4;
4295     }
4296 #endif
4297
4298     CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), (
4299         *(GLenum   *)(pc +  0),
4300         *(GLuint   *)(pc +  4),
4301          (const GLdouble *)(pc +  8)
4302     ) );
4303 }
4304
4305 void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
4306 {
4307     CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), (
4308         *(GLenum   *)(pc +  0),
4309         *(GLuint   *)(pc +  4),
4310          (const GLfloat *)(pc +  8)
4311     ) );
4312 }
4313
4314 void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
4315 {
4316 #ifdef __GLX_ALIGN64
4317     if ((unsigned long)(pc) & 7) {
4318         (void) memmove(pc-4, pc, 40);
4319         pc -= 4;
4320     }
4321 #endif
4322
4323     CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), (
4324         *(GLenum   *)(pc +  0),
4325         *(GLuint   *)(pc +  4),
4326          (const GLdouble *)(pc +  8)
4327     ) );
4328 }
4329
4330 void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
4331 {
4332     CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), (
4333         *(GLenum   *)(pc +  0),
4334         *(GLuint   *)(pc +  4),
4335          (const GLfloat *)(pc +  8)
4336     ) );
4337 }
4338
4339 void __glXDisp_ProgramStringARB(GLbyte * pc)
4340 {
4341     const GLsizei len = *(GLsizei  *)(pc +  8);
4342
4343     CALL_ProgramStringARB( GET_DISPATCH(), (
4344         *(GLenum   *)(pc +  0),
4345         *(GLenum   *)(pc +  4),
4346         len,
4347          (const GLvoid *)(pc + 12)
4348     ) );
4349 }
4350
4351 void __glXDisp_VertexAttrib1dvARB(GLbyte * pc)
4352 {
4353 #ifdef __GLX_ALIGN64
4354     if ((unsigned long)(pc) & 7) {
4355         (void) memmove(pc-4, pc, 12);
4356         pc -= 4;
4357     }
4358 #endif
4359
4360     CALL_VertexAttrib1dvARB( GET_DISPATCH(), (
4361         *(GLuint   *)(pc +  0),
4362          (const GLdouble *)(pc +  4)
4363     ) );
4364 }
4365
4366 void __glXDisp_VertexAttrib1fvARB(GLbyte * pc)
4367 {
4368     CALL_VertexAttrib1fvARB( GET_DISPATCH(), (
4369         *(GLuint   *)(pc +  0),
4370          (const GLfloat *)(pc +  4)
4371     ) );
4372 }
4373
4374 void __glXDisp_VertexAttrib1svARB(GLbyte * pc)
4375 {
4376     CALL_VertexAttrib1svARB( GET_DISPATCH(), (
4377         *(GLuint   *)(pc +  0),
4378          (const GLshort *)(pc +  4)
4379     ) );
4380 }
4381
4382 void __glXDisp_VertexAttrib2dvARB(GLbyte * pc)
4383 {
4384 #ifdef __GLX_ALIGN64
4385     if ((unsigned long)(pc) & 7) {
4386         (void) memmove(pc-4, pc, 20);
4387         pc -= 4;
4388     }
4389 #endif
4390
4391     CALL_VertexAttrib2dvARB( GET_DISPATCH(), (
4392         *(GLuint   *)(pc +  0),
4393          (const GLdouble *)(pc +  4)
4394     ) );
4395 }
4396
4397 void __glXDisp_VertexAttrib2fvARB(GLbyte * pc)
4398 {
4399     CALL_VertexAttrib2fvARB( GET_DISPATCH(), (
4400         *(GLuint   *)(pc +  0),
4401          (const GLfloat *)(pc +  4)
4402     ) );
4403 }
4404
4405 void __glXDisp_VertexAttrib2svARB(GLbyte * pc)
4406 {
4407     CALL_VertexAttrib2svARB( GET_DISPATCH(), (
4408         *(GLuint   *)(pc +  0),
4409          (const GLshort *)(pc +  4)
4410     ) );
4411 }
4412
4413 void __glXDisp_VertexAttrib3dvARB(GLbyte * pc)
4414 {
4415 #ifdef __GLX_ALIGN64
4416     if ((unsigned long)(pc) & 7) {
4417         (void) memmove(pc-4, pc, 28);
4418         pc -= 4;
4419     }
4420 #endif
4421
4422     CALL_VertexAttrib3dvARB( GET_DISPATCH(), (
4423         *(GLuint   *)(pc +  0),
4424          (const GLdouble *)(pc +  4)
4425     ) );
4426 }
4427
4428 void __glXDisp_VertexAttrib3fvARB(GLbyte * pc)
4429 {
4430     CALL_VertexAttrib3fvARB( GET_DISPATCH(), (
4431         *(GLuint   *)(pc +  0),
4432          (const GLfloat *)(pc +  4)
4433     ) );
4434 }
4435
4436 void __glXDisp_VertexAttrib3svARB(GLbyte * pc)
4437 {
4438     CALL_VertexAttrib3svARB( GET_DISPATCH(), (
4439         *(GLuint   *)(pc +  0),
4440          (const GLshort *)(pc +  4)
4441     ) );
4442 }
4443
4444 void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc)
4445 {
4446     CALL_VertexAttrib4NbvARB( GET_DISPATCH(), (
4447         *(GLuint   *)(pc +  0),
4448          (const GLbyte *)(pc +  4)
4449     ) );
4450 }
4451
4452 void __glXDisp_VertexAttrib4NivARB(GLbyte * pc)
4453 {
4454     CALL_VertexAttrib4NivARB( GET_DISPATCH(), (
4455         *(GLuint   *)(pc +  0),
4456          (const GLint *)(pc +  4)
4457     ) );
4458 }
4459
4460 void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc)
4461 {
4462     CALL_VertexAttrib4NsvARB( GET_DISPATCH(), (
4463         *(GLuint   *)(pc +  0),
4464          (const GLshort *)(pc +  4)
4465     ) );
4466 }
4467
4468 void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc)
4469 {
4470     CALL_VertexAttrib4NubvARB( GET_DISPATCH(), (
4471         *(GLuint   *)(pc +  0),
4472          (const GLubyte *)(pc +  4)
4473     ) );
4474 }
4475
4476 void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc)
4477 {
4478     CALL_VertexAttrib4NuivARB( GET_DISPATCH(), (
4479         *(GLuint   *)(pc +  0),
4480          (const GLuint *)(pc +  4)
4481     ) );
4482 }
4483
4484 void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc)
4485 {
4486     CALL_VertexAttrib4NusvARB( GET_DISPATCH(), (
4487         *(GLuint   *)(pc +  0),
4488          (const GLushort *)(pc +  4)
4489     ) );
4490 }
4491
4492 void __glXDisp_VertexAttrib4bvARB(GLbyte * pc)
4493 {
4494     CALL_VertexAttrib4bvARB( GET_DISPATCH(), (
4495         *(GLuint   *)(pc +  0),
4496          (const GLbyte *)(pc +  4)
4497     ) );
4498 }
4499
4500 void __glXDisp_VertexAttrib4dvARB(GLbyte * pc)
4501 {
4502 #ifdef __GLX_ALIGN64
4503     if ((unsigned long)(pc) & 7) {
4504         (void) memmove(pc-4, pc, 36);
4505         pc -= 4;
4506     }
4507 #endif
4508
4509     CALL_VertexAttrib4dvARB( GET_DISPATCH(), (
4510         *(GLuint   *)(pc +  0),
4511          (const GLdouble *)(pc +  4)
4512     ) );
4513 }
4514
4515 void __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
4516 {
4517     CALL_VertexAttrib4fvARB( GET_DISPATCH(), (
4518         *(GLuint   *)(pc +  0),
4519          (const GLfloat *)(pc +  4)
4520     ) );
4521 }
4522
4523 void __glXDisp_VertexAttrib4ivARB(GLbyte * pc)
4524 {
4525     CALL_VertexAttrib4ivARB( GET_DISPATCH(), (
4526         *(GLuint   *)(pc +  0),
4527          (const GLint *)(pc +  4)
4528     ) );
4529 }
4530
4531 void __glXDisp_VertexAttrib4svARB(GLbyte * pc)
4532 {
4533     CALL_VertexAttrib4svARB( GET_DISPATCH(), (
4534         *(GLuint   *)(pc +  0),
4535          (const GLshort *)(pc +  4)
4536     ) );
4537 }
4538
4539 void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc)
4540 {
4541     CALL_VertexAttrib4ubvARB( GET_DISPATCH(), (
4542         *(GLuint   *)(pc +  0),
4543          (const GLubyte *)(pc +  4)
4544     ) );
4545 }
4546
4547 void __glXDisp_VertexAttrib4uivARB(GLbyte * pc)
4548 {
4549     CALL_VertexAttrib4uivARB( GET_DISPATCH(), (
4550         *(GLuint   *)(pc +  0),
4551          (const GLuint *)(pc +  4)
4552     ) );
4553 }
4554
4555 void __glXDisp_VertexAttrib4usvARB(GLbyte * pc)
4556 {
4557     CALL_VertexAttrib4usvARB( GET_DISPATCH(), (
4558         *(GLuint   *)(pc +  0),
4559          (const GLushort *)(pc +  4)
4560     ) );
4561 }
4562
4563 void __glXDisp_BeginQueryARB(GLbyte * pc)
4564 {
4565     CALL_BeginQueryARB( GET_DISPATCH(), (
4566         *(GLenum   *)(pc +  0),
4567         *(GLuint   *)(pc +  4)
4568     ) );
4569 }
4570
4571 int __glXDisp_DeleteQueriesARB(__GLXclientState *cl, GLbyte *pc)
4572 {
4573     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
4574     int error;
4575     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4576
4577     pc += __GLX_SINGLE_HDR_SIZE;
4578     if ( cx != NULL ) {
4579         const GLsizei n = *(GLsizei  *)(pc +  0);
4580
4581         CALL_DeleteQueriesARB( GET_DISPATCH(), (
4582             n,
4583              (const GLuint *)(pc +  4)
4584         ) );
4585         error = Success;
4586     }
4587
4588     return error;
4589 }
4590
4591 void __glXDisp_EndQueryARB(GLbyte * pc)
4592 {
4593     CALL_EndQueryARB( GET_DISPATCH(), (
4594         *(GLenum   *)(pc +  0)
4595     ) );
4596 }
4597
4598 int __glXDisp_GenQueriesARB(__GLXclientState *cl, GLbyte *pc)
4599 {
4600     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
4601     int error;
4602     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4603
4604     pc += __GLX_SINGLE_HDR_SIZE;
4605     if ( cx != NULL ) {
4606         const GLsizei n = *(GLsizei  *)(pc +  0);
4607
4608         GLuint answerBuffer[200];
4609         GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
4610         CALL_GenQueriesARB( GET_DISPATCH(), (
4611             n,
4612             ids
4613         ) );
4614         __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
4615         error = Success;
4616     }
4617
4618     return error;
4619 }
4620
4621 int __glXDisp_GetQueryObjectivARB(__GLXclientState *cl, GLbyte *pc)
4622 {
4623     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
4624     int error;
4625     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4626
4627     pc += __GLX_SINGLE_HDR_SIZE;
4628     if ( cx != NULL ) {
4629         const GLenum pname = *(GLenum   *)(pc +  4);
4630
4631         const GLuint compsize = __glGetQueryObjectivARB_size(pname);
4632         GLint answerBuffer[200];
4633         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
4634
4635         if (params == NULL) return BadAlloc;
4636         __glXClearErrorOccured();
4637
4638         CALL_GetQueryObjectivARB( GET_DISPATCH(), (
4639             *(GLuint   *)(pc +  0),
4640             pname,
4641             params
4642         ) );
4643         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
4644         error = Success;
4645     }
4646
4647     return error;
4648 }
4649
4650 int __glXDisp_GetQueryObjectuivARB(__GLXclientState *cl, GLbyte *pc)
4651 {
4652     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
4653     int error;
4654     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4655
4656     pc += __GLX_SINGLE_HDR_SIZE;
4657     if ( cx != NULL ) {
4658         const GLenum pname = *(GLenum   *)(pc +  4);
4659
4660         const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
4661         GLuint answerBuffer[200];
4662         GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
4663
4664         if (params == NULL) return BadAlloc;
4665         __glXClearErrorOccured();
4666
4667         CALL_GetQueryObjectuivARB( GET_DISPATCH(), (
4668             *(GLuint   *)(pc +  0),
4669             pname,
4670             params
4671         ) );
4672         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
4673         error = Success;
4674     }
4675
4676     return error;
4677 }
4678
4679 int __glXDisp_GetQueryivARB(__GLXclientState *cl, GLbyte *pc)
4680 {
4681     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
4682     int error;
4683     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4684
4685     pc += __GLX_SINGLE_HDR_SIZE;
4686     if ( cx != NULL ) {
4687         const GLenum pname = *(GLenum   *)(pc +  4);
4688
4689         const GLuint compsize = __glGetQueryivARB_size(pname);
4690         GLint answerBuffer[200];
4691         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
4692
4693         if (params == NULL) return BadAlloc;
4694         __glXClearErrorOccured();
4695
4696         CALL_GetQueryivARB( GET_DISPATCH(), (
4697             *(GLenum   *)(pc +  0),
4698             pname,
4699             params
4700         ) );
4701         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
4702         error = Success;
4703     }
4704
4705     return error;
4706 }
4707
4708 int __glXDisp_IsQueryARB(__GLXclientState *cl, GLbyte *pc)
4709 {
4710     xGLXSingleReq * const req = (xGLXSingleReq *) pc;
4711     int error;
4712     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4713
4714     pc += __GLX_SINGLE_HDR_SIZE;
4715     if ( cx != NULL ) {
4716         GLboolean retval;
4717         retval = CALL_IsQueryARB( GET_DISPATCH(), (
4718             *(GLuint   *)(pc +  0)
4719         ) );
4720         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
4721         error = Success;
4722     }
4723
4724     return error;
4725 }
4726
4727 void __glXDisp_DrawBuffersARB(GLbyte * pc)
4728 {
4729     const GLsizei n = *(GLsizei  *)(pc +  0);
4730
4731     CALL_DrawBuffersARB( GET_DISPATCH(), (
4732         n,
4733          (const GLenum *)(pc +  4)
4734     ) );
4735 }
4736
4737 void __glXDisp_SampleMaskSGIS(GLbyte * pc)
4738 {
4739     CALL_SampleMaskSGIS( GET_DISPATCH(), (
4740         *(GLclampf *)(pc +  0),
4741         *(GLboolean *)(pc +  4)
4742     ) );
4743 }
4744
4745 void __glXDisp_SamplePatternSGIS(GLbyte * pc)
4746 {
4747     CALL_SamplePatternSGIS( GET_DISPATCH(), (
4748         *(GLenum   *)(pc +  0)
4749     ) );
4750 }
4751
4752 void __glXDisp_PointParameterfEXT(GLbyte * pc)
4753 {
4754     CALL_PointParameterfEXT( GET_DISPATCH(), (
4755         *(GLenum   *)(pc +  0),
4756         *(GLfloat  *)(pc +  4)
4757     ) );
4758 }
4759
4760 void __glXDisp_PointParameterfvEXT(GLbyte * pc)
4761 {
4762     const GLenum pname = *(GLenum   *)(pc +  0);
4763     const GLfloat * params;
4764
4765     params = (const GLfloat *) (pc + 4);
4766
4767     CALL_PointParameterfvEXT( GET_DISPATCH(), (
4768         pname,
4769         params
4770     ) );
4771 }
4772
4773 void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc)
4774 {
4775     CALL_SecondaryColor3bvEXT( GET_DISPATCH(), (
4776          (const GLbyte *)(pc +  0)
4777     ) );
4778 }
4779
4780 void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc)
4781 {
4782 #ifdef __GLX_ALIGN64
4783     if ((unsigned long)(pc) & 7) {
4784         (void) memmove(pc-4, pc, 24);
4785         pc -= 4;
4786     }
4787 #endif
4788
4789     CALL_SecondaryColor3dvEXT( GET_DISPATCH(), (
4790          (const GLdouble *)(pc +  0)
4791     ) );
4792 }
4793
4794 void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
4795 {
4796     CALL_SecondaryColor3fvEXT( GET_DISPATCH(), (
4797          (const GLfloat *)(pc +  0)
4798     ) );
4799 }
4800
4801 void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc)
4802 {
4803     CALL_SecondaryColor3ivEXT( GET_DISPATCH(), (
4804          (const GLint *)(pc +  0)
4805     ) );
4806 }
4807
4808 void __glXDisp_SecondaryColor3svEXT(GLbyte * pc)
4809 {
4810     CALL_SecondaryColor3svEXT( GET_DISPATCH(), (
4811          (const GLshort *)(pc +  0)
4812     ) );
4813 }
4814
4815 void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc)
4816 {
4817     CALL_SecondaryColor3ubvEXT( GET_DISPATCH(), (
4818          (const GLubyte *)(pc +  0)
4819     ) );
4820 }
4821
4822 void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc)
4823 {
4824     CALL_SecondaryColor3uivEXT( GET_DISPATCH(), (
4825          (const GLuint *)(pc +  0)
4826     ) );
4827 }
4828
4829 void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc)
4830 {
4831     CALL_SecondaryColor3usvEXT( GET_DISPATCH(), (
4832          (const GLushort *)(pc +  0)
4833     ) );
4834 }
4835
4836 void __glXDisp_FogCoorddvEXT(GLbyte * pc)
4837 {
4838 #ifdef __GLX_ALIGN64
4839     if ((unsigned long)(pc) & 7) {
4840         (void) memmove(pc-4, pc, 8);
4841         pc -= 4;
4842     }
4843 #endif
4844
4845     CALL_FogCoorddvEXT( GET_DISPATCH(), (
4846          (const GLdouble *)(pc +  0)
4847     ) );
4848 }
4849
4850 void __glXDisp_FogCoordfvEXT(GLbyte * pc)
4851 {
4852     CALL_FogCoordfvEXT( GET_DISPATCH(), (
4853          (const GLfloat *)(pc +  0)
4854     ) );
4855 }
4856
4857 void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc)
4858 {
4859     CALL_BlendFuncSeparateEXT( GET_DISPATCH(), (
4860         *(GLenum   *)(pc +  0),
4861         *(GLenum   *)(pc +  4),
4862         *(GLenum   *)(pc +  8),
4863         *(GLenum   *)(pc + 12)
4864     ) );
4865 }
4866
4867 void __glXDisp_WindowPos3fvMESA(GLbyte * pc)
4868 {
4869     CALL_WindowPos3fvMESA( GET_DISPATCH(), (
4870          (const GLfloat *)(pc +  0)
4871     ) );
4872 }
4873
4874 int __glXDisp_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
4875 {
4876     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4877     int error;
4878     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4879
4880     pc += __GLX_VENDPRIV_HDR_SIZE;
4881     if ( cx != NULL ) {
4882         const GLsizei n = *(GLsizei  *)(pc +  0);
4883
4884         GLboolean retval;
4885         GLboolean answerBuffer[200];
4886         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
4887         retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
4888             n,
4889              (const GLuint *)(pc +  4),
4890             residences
4891         ) );
4892         __glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval);
4893         error = Success;
4894     }
4895
4896     return error;
4897 }
4898
4899 void __glXDisp_BindProgramNV(GLbyte * pc)
4900 {
4901     CALL_BindProgramNV( GET_DISPATCH(), (
4902         *(GLenum   *)(pc +  0),
4903         *(GLuint   *)(pc +  4)
4904     ) );
4905 }
4906
4907 int __glXDisp_DeleteProgramsNV(__GLXclientState *cl, GLbyte *pc)
4908 {
4909     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4910     int error;
4911     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4912
4913     pc += __GLX_VENDPRIV_HDR_SIZE;
4914     if ( cx != NULL ) {
4915         const GLsizei n = *(GLsizei  *)(pc +  0);
4916
4917         CALL_DeleteProgramsNV( GET_DISPATCH(), (
4918             n,
4919              (const GLuint *)(pc +  4)
4920         ) );
4921         error = Success;
4922     }
4923
4924     return error;
4925 }
4926
4927 void __glXDisp_ExecuteProgramNV(GLbyte * pc)
4928 {
4929     CALL_ExecuteProgramNV( GET_DISPATCH(), (
4930         *(GLenum   *)(pc +  0),
4931         *(GLuint   *)(pc +  4),
4932          (const GLfloat *)(pc +  8)
4933     ) );
4934 }
4935
4936 int __glXDisp_GenProgramsNV(__GLXclientState *cl, GLbyte *pc)
4937 {
4938     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4939     int error;
4940     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4941
4942     pc += __GLX_VENDPRIV_HDR_SIZE;
4943     if ( cx != NULL ) {
4944         const GLsizei n = *(GLsizei  *)(pc +  0);
4945
4946         GLuint answerBuffer[200];
4947         GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
4948         CALL_GenProgramsNV( GET_DISPATCH(), (
4949             n,
4950             programs
4951         ) );
4952         __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0);
4953         error = Success;
4954     }
4955
4956     return error;
4957 }
4958
4959 int __glXDisp_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
4960 {
4961     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4962     int error;
4963     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4964
4965     pc += __GLX_VENDPRIV_HDR_SIZE;
4966     if ( cx != NULL ) {
4967         GLdouble params[4];
4968         CALL_GetProgramParameterdvNV( GET_DISPATCH(), (
4969             *(GLenum   *)(pc +  0),
4970             *(GLuint   *)(pc +  4),
4971             *(GLenum   *)(pc +  8),
4972             params
4973         ) );
4974         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
4975         error = Success;
4976     }
4977
4978     return error;
4979 }
4980
4981 int __glXDisp_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
4982 {
4983     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
4984     int error;
4985     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
4986
4987     pc += __GLX_VENDPRIV_HDR_SIZE;
4988     if ( cx != NULL ) {
4989         GLfloat params[4];
4990         CALL_GetProgramParameterfvNV( GET_DISPATCH(), (
4991             *(GLenum   *)(pc +  0),
4992             *(GLuint   *)(pc +  4),
4993             *(GLenum   *)(pc +  8),
4994             params
4995         ) );
4996         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
4997         error = Success;
4998     }
4999
5000     return error;
5001 }
5002
5003 int __glXDisp_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
5004 {
5005     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5006     int error;
5007     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5008
5009     pc += __GLX_VENDPRIV_HDR_SIZE;
5010     if ( cx != NULL ) {
5011         const GLenum pname = *(GLenum   *)(pc +  4);
5012
5013         const GLuint compsize = __glGetProgramivNV_size(pname);
5014         GLint answerBuffer[200];
5015         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
5016
5017         if (params == NULL) return BadAlloc;
5018         __glXClearErrorOccured();
5019
5020         CALL_GetProgramivNV( GET_DISPATCH(), (
5021             *(GLuint   *)(pc +  0),
5022             pname,
5023             params
5024         ) );
5025         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
5026         error = Success;
5027     }
5028
5029     return error;
5030 }
5031
5032 int __glXDisp_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
5033 {
5034     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5035     int error;
5036     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5037
5038     pc += __GLX_VENDPRIV_HDR_SIZE;
5039     if ( cx != NULL ) {
5040         GLint params[1];
5041         CALL_GetTrackMatrixivNV( GET_DISPATCH(), (
5042             *(GLenum   *)(pc +  0),
5043             *(GLuint   *)(pc +  4),
5044             *(GLenum   *)(pc +  8),
5045             params
5046         ) );
5047         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
5048         error = Success;
5049     }
5050
5051     return error;
5052 }
5053
5054 int __glXDisp_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
5055 {
5056     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5057     int error;
5058     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5059
5060     pc += __GLX_VENDPRIV_HDR_SIZE;
5061     if ( cx != NULL ) {
5062         const GLenum pname = *(GLenum   *)(pc +  4);
5063
5064         const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
5065         GLdouble answerBuffer[200];
5066         GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
5067
5068         if (params == NULL) return BadAlloc;
5069         __glXClearErrorOccured();
5070
5071         CALL_GetVertexAttribdvNV( GET_DISPATCH(), (
5072             *(GLuint   *)(pc +  0),
5073             pname,
5074             params
5075         ) );
5076         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
5077         error = Success;
5078     }
5079
5080     return error;
5081 }
5082
5083 int __glXDisp_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
5084 {
5085     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5086     int error;
5087     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5088
5089     pc += __GLX_VENDPRIV_HDR_SIZE;
5090     if ( cx != NULL ) {
5091         const GLenum pname = *(GLenum   *)(pc +  4);
5092
5093         const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
5094         GLfloat answerBuffer[200];
5095         GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
5096
5097         if (params == NULL) return BadAlloc;
5098         __glXClearErrorOccured();
5099
5100         CALL_GetVertexAttribfvNV( GET_DISPATCH(), (
5101             *(GLuint   *)(pc +  0),
5102             pname,
5103             params
5104         ) );
5105         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
5106         error = Success;
5107     }
5108
5109     return error;
5110 }
5111
5112 int __glXDisp_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
5113 {
5114     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5115     int error;
5116     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5117
5118     pc += __GLX_VENDPRIV_HDR_SIZE;
5119     if ( cx != NULL ) {
5120         const GLenum pname = *(GLenum   *)(pc +  4);
5121
5122         const GLuint compsize = __glGetVertexAttribivNV_size(pname);
5123         GLint answerBuffer[200];
5124         GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
5125
5126         if (params == NULL) return BadAlloc;
5127         __glXClearErrorOccured();
5128
5129         CALL_GetVertexAttribivNV( GET_DISPATCH(), (
5130             *(GLuint   *)(pc +  0),
5131             pname,
5132             params
5133         ) );
5134         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
5135         error = Success;
5136     }
5137
5138     return error;
5139 }
5140
5141 int __glXDisp_IsProgramNV(__GLXclientState *cl, GLbyte *pc)
5142 {
5143     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5144     int error;
5145     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5146
5147     pc += __GLX_VENDPRIV_HDR_SIZE;
5148     if ( cx != NULL ) {
5149         GLboolean retval;
5150         retval = CALL_IsProgramNV( GET_DISPATCH(), (
5151             *(GLuint   *)(pc +  0)
5152         ) );
5153         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5154         error = Success;
5155     }
5156
5157     return error;
5158 }
5159
5160 void __glXDisp_LoadProgramNV(GLbyte * pc)
5161 {
5162     const GLsizei len = *(GLsizei  *)(pc +  8);
5163
5164     CALL_LoadProgramNV( GET_DISPATCH(), (
5165         *(GLenum   *)(pc +  0),
5166         *(GLuint   *)(pc +  4),
5167         len,
5168          (const GLubyte *)(pc + 12)
5169     ) );
5170 }
5171
5172 void __glXDisp_ProgramParameters4dvNV(GLbyte * pc)
5173 {
5174     const GLuint num = *(GLuint   *)(pc +  8);
5175
5176 #ifdef __GLX_ALIGN64
5177     const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;
5178     if ((unsigned long)(pc) & 7) {
5179         (void) memmove(pc-4, pc, cmdlen);
5180         pc -= 4;
5181     }
5182 #endif
5183
5184     CALL_ProgramParameters4dvNV( GET_DISPATCH(), (
5185         *(GLenum   *)(pc +  0),
5186         *(GLuint   *)(pc +  4),
5187         num,
5188          (const GLdouble *)(pc + 12)
5189     ) );
5190 }
5191
5192 void __glXDisp_ProgramParameters4fvNV(GLbyte * pc)
5193 {
5194     const GLuint num = *(GLuint   *)(pc +  8);
5195
5196     CALL_ProgramParameters4fvNV( GET_DISPATCH(), (
5197         *(GLenum   *)(pc +  0),
5198         *(GLuint   *)(pc +  4),
5199         num,
5200          (const GLfloat *)(pc + 12)
5201     ) );
5202 }
5203
5204 void __glXDisp_RequestResidentProgramsNV(GLbyte * pc)
5205 {
5206     const GLsizei n = *(GLsizei  *)(pc +  0);
5207
5208     CALL_RequestResidentProgramsNV( GET_DISPATCH(), (
5209         n,
5210          (const GLuint *)(pc +  4)
5211     ) );
5212 }
5213
5214 void __glXDisp_TrackMatrixNV(GLbyte * pc)
5215 {
5216     CALL_TrackMatrixNV( GET_DISPATCH(), (
5217         *(GLenum   *)(pc +  0),
5218         *(GLuint   *)(pc +  4),
5219         *(GLenum   *)(pc +  8),
5220         *(GLenum   *)(pc + 12)
5221     ) );
5222 }
5223
5224 void __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
5225 {
5226 #ifdef __GLX_ALIGN64
5227     if ((unsigned long)(pc) & 7) {
5228         (void) memmove(pc-4, pc, 12);
5229         pc -= 4;
5230     }
5231 #endif
5232
5233     CALL_VertexAttrib1dvNV( GET_DISPATCH(), (
5234         *(GLuint   *)(pc +  0),
5235          (const GLdouble *)(pc +  4)
5236     ) );
5237 }
5238
5239 void __glXDisp_VertexAttrib1fvNV(GLbyte * pc)
5240 {
5241     CALL_VertexAttrib1fvNV( GET_DISPATCH(), (
5242         *(GLuint   *)(pc +  0),
5243          (const GLfloat *)(pc +  4)
5244     ) );
5245 }
5246
5247 void __glXDisp_VertexAttrib1svNV(GLbyte * pc)
5248 {
5249     CALL_VertexAttrib1svNV( GET_DISPATCH(), (
5250         *(GLuint   *)(pc +  0),
5251          (const GLshort *)(pc +  4)
5252     ) );
5253 }
5254
5255 void __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
5256 {
5257 #ifdef __GLX_ALIGN64
5258     if ((unsigned long)(pc) & 7) {
5259         (void) memmove(pc-4, pc, 20);
5260         pc -= 4;
5261     }
5262 #endif
5263
5264     CALL_VertexAttrib2dvNV( GET_DISPATCH(), (
5265         *(GLuint   *)(pc +  0),
5266          (const GLdouble *)(pc +  4)
5267     ) );
5268 }
5269
5270 void __glXDisp_VertexAttrib2fvNV(GLbyte * pc)
5271 {
5272     CALL_VertexAttrib2fvNV( GET_DISPATCH(), (
5273         *(GLuint   *)(pc +  0),
5274          (const GLfloat *)(pc +  4)
5275     ) );
5276 }
5277
5278 void __glXDisp_VertexAttrib2svNV(GLbyte * pc)
5279 {
5280     CALL_VertexAttrib2svNV( GET_DISPATCH(), (
5281         *(GLuint   *)(pc +  0),
5282          (const GLshort *)(pc +  4)
5283     ) );
5284 }
5285
5286 void __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
5287 {
5288 #ifdef __GLX_ALIGN64
5289     if ((unsigned long)(pc) & 7) {
5290         (void) memmove(pc-4, pc, 28);
5291         pc -= 4;
5292     }
5293 #endif
5294
5295     CALL_VertexAttrib3dvNV( GET_DISPATCH(), (
5296         *(GLuint   *)(pc +  0),
5297          (const GLdouble *)(pc +  4)
5298     ) );
5299 }
5300
5301 void __glXDisp_VertexAttrib3fvNV(GLbyte * pc)
5302 {
5303     CALL_VertexAttrib3fvNV( GET_DISPATCH(), (
5304         *(GLuint   *)(pc +  0),
5305          (const GLfloat *)(pc +  4)
5306     ) );
5307 }
5308
5309 void __glXDisp_VertexAttrib3svNV(GLbyte * pc)
5310 {
5311     CALL_VertexAttrib3svNV( GET_DISPATCH(), (
5312         *(GLuint   *)(pc +  0),
5313          (const GLshort *)(pc +  4)
5314     ) );
5315 }
5316
5317 void __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
5318 {
5319 #ifdef __GLX_ALIGN64
5320     if ((unsigned long)(pc) & 7) {
5321         (void) memmove(pc-4, pc, 36);
5322         pc -= 4;
5323     }
5324 #endif
5325
5326     CALL_VertexAttrib4dvNV( GET_DISPATCH(), (
5327         *(GLuint   *)(pc +  0),
5328          (const GLdouble *)(pc +  4)
5329     ) );
5330 }
5331
5332 void __glXDisp_VertexAttrib4fvNV(GLbyte * pc)
5333 {
5334     CALL_VertexAttrib4fvNV( GET_DISPATCH(), (
5335         *(GLuint   *)(pc +  0),
5336          (const GLfloat *)(pc +  4)
5337     ) );
5338 }
5339
5340 void __glXDisp_VertexAttrib4svNV(GLbyte * pc)
5341 {
5342     CALL_VertexAttrib4svNV( GET_DISPATCH(), (
5343         *(GLuint   *)(pc +  0),
5344          (const GLshort *)(pc +  4)
5345     ) );
5346 }
5347
5348 void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
5349 {
5350     CALL_VertexAttrib4ubvNV( GET_DISPATCH(), (
5351         *(GLuint   *)(pc +  0),
5352          (const GLubyte *)(pc +  4)
5353     ) );
5354 }
5355
5356 void __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
5357 {
5358     const GLsizei n = *(GLsizei  *)(pc +  4);
5359
5360 #ifdef __GLX_ALIGN64
5361     const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
5362     if ((unsigned long)(pc) & 7) {
5363         (void) memmove(pc-4, pc, cmdlen);
5364         pc -= 4;
5365     }
5366 #endif
5367
5368     CALL_VertexAttribs1dvNV( GET_DISPATCH(), (
5369         *(GLuint   *)(pc +  0),
5370         n,
5371          (const GLdouble *)(pc +  8)
5372     ) );
5373 }
5374
5375 void __glXDisp_VertexAttribs1fvNV(GLbyte * pc)
5376 {
5377     const GLsizei n = *(GLsizei  *)(pc +  4);
5378
5379     CALL_VertexAttribs1fvNV( GET_DISPATCH(), (
5380         *(GLuint   *)(pc +  0),
5381         n,
5382          (const GLfloat *)(pc +  8)
5383     ) );
5384 }
5385
5386 void __glXDisp_VertexAttribs1svNV(GLbyte * pc)
5387 {
5388     const GLsizei n = *(GLsizei  *)(pc +  4);
5389
5390     CALL_VertexAttribs1svNV( GET_DISPATCH(), (
5391         *(GLuint   *)(pc +  0),
5392         n,
5393          (const GLshort *)(pc +  8)
5394     ) );
5395 }
5396
5397 void __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
5398 {
5399     const GLsizei n = *(GLsizei  *)(pc +  4);
5400
5401 #ifdef __GLX_ALIGN64
5402     const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
5403     if ((unsigned long)(pc) & 7) {
5404         (void) memmove(pc-4, pc, cmdlen);
5405         pc -= 4;
5406     }
5407 #endif
5408
5409     CALL_VertexAttribs2dvNV( GET_DISPATCH(), (
5410         *(GLuint   *)(pc +  0),
5411         n,
5412          (const GLdouble *)(pc +  8)
5413     ) );
5414 }
5415
5416 void __glXDisp_VertexAttribs2fvNV(GLbyte * pc)
5417 {
5418     const GLsizei n = *(GLsizei  *)(pc +  4);
5419
5420     CALL_VertexAttribs2fvNV( GET_DISPATCH(), (
5421         *(GLuint   *)(pc +  0),
5422         n,
5423          (const GLfloat *)(pc +  8)
5424     ) );
5425 }
5426
5427 void __glXDisp_VertexAttribs2svNV(GLbyte * pc)
5428 {
5429     const GLsizei n = *(GLsizei  *)(pc +  4);
5430
5431     CALL_VertexAttribs2svNV( GET_DISPATCH(), (
5432         *(GLuint   *)(pc +  0),
5433         n,
5434          (const GLshort *)(pc +  8)
5435     ) );
5436 }
5437
5438 void __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
5439 {
5440     const GLsizei n = *(GLsizei  *)(pc +  4);
5441
5442 #ifdef __GLX_ALIGN64
5443     const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
5444     if ((unsigned long)(pc) & 7) {
5445         (void) memmove(pc-4, pc, cmdlen);
5446         pc -= 4;
5447     }
5448 #endif
5449
5450     CALL_VertexAttribs3dvNV( GET_DISPATCH(), (
5451         *(GLuint   *)(pc +  0),
5452         n,
5453          (const GLdouble *)(pc +  8)
5454     ) );
5455 }
5456
5457 void __glXDisp_VertexAttribs3fvNV(GLbyte * pc)
5458 {
5459     const GLsizei n = *(GLsizei  *)(pc +  4);
5460
5461     CALL_VertexAttribs3fvNV( GET_DISPATCH(), (
5462         *(GLuint   *)(pc +  0),
5463         n,
5464          (const GLfloat *)(pc +  8)
5465     ) );
5466 }
5467
5468 void __glXDisp_VertexAttribs3svNV(GLbyte * pc)
5469 {
5470     const GLsizei n = *(GLsizei  *)(pc +  4);
5471
5472     CALL_VertexAttribs3svNV( GET_DISPATCH(), (
5473         *(GLuint   *)(pc +  0),
5474         n,
5475          (const GLshort *)(pc +  8)
5476     ) );
5477 }
5478
5479 void __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
5480 {
5481     const GLsizei n = *(GLsizei  *)(pc +  4);
5482
5483 #ifdef __GLX_ALIGN64
5484     const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
5485     if ((unsigned long)(pc) & 7) {
5486         (void) memmove(pc-4, pc, cmdlen);
5487         pc -= 4;
5488     }
5489 #endif
5490
5491     CALL_VertexAttribs4dvNV( GET_DISPATCH(), (
5492         *(GLuint   *)(pc +  0),
5493         n,
5494          (const GLdouble *)(pc +  8)
5495     ) );
5496 }
5497
5498 void __glXDisp_VertexAttribs4fvNV(GLbyte * pc)
5499 {
5500     const GLsizei n = *(GLsizei  *)(pc +  4);
5501
5502     CALL_VertexAttribs4fvNV( GET_DISPATCH(), (
5503         *(GLuint   *)(pc +  0),
5504         n,
5505          (const GLfloat *)(pc +  8)
5506     ) );
5507 }
5508
5509 void __glXDisp_VertexAttribs4svNV(GLbyte * pc)
5510 {
5511     const GLsizei n = *(GLsizei  *)(pc +  4);
5512
5513     CALL_VertexAttribs4svNV( GET_DISPATCH(), (
5514         *(GLuint   *)(pc +  0),
5515         n,
5516          (const GLshort *)(pc +  8)
5517     ) );
5518 }
5519
5520 void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
5521 {
5522     const GLsizei n = *(GLsizei  *)(pc +  4);
5523
5524     CALL_VertexAttribs4ubvNV( GET_DISPATCH(), (
5525         *(GLuint   *)(pc +  0),
5526         n,
5527          (const GLubyte *)(pc +  8)
5528     ) );
5529 }
5530
5531 void __glXDisp_PointParameteriNV(GLbyte * pc)
5532 {
5533     CALL_PointParameteriNV( GET_DISPATCH(), (
5534         *(GLenum   *)(pc +  0),
5535         *(GLint    *)(pc +  4)
5536     ) );
5537 }
5538
5539 void __glXDisp_PointParameterivNV(GLbyte * pc)
5540 {
5541     const GLenum pname = *(GLenum   *)(pc +  0);
5542     const GLint * params;
5543
5544     params = (const GLint *) (pc + 4);
5545
5546     CALL_PointParameterivNV( GET_DISPATCH(), (
5547         pname,
5548         params
5549     ) );
5550 }
5551
5552 void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
5553 {
5554     CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
5555         *(GLenum   *)(pc +  0)
5556     ) );
5557 }
5558
5559 int __glXDisp_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
5560 {
5561     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5562     int error;
5563     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5564
5565     pc += __GLX_VENDPRIV_HDR_SIZE;
5566     if ( cx != NULL ) {
5567         const GLsizei len = *(GLsizei  *)(pc +  4);
5568
5569         GLdouble params[4];
5570         CALL_GetProgramNamedParameterdvNV( GET_DISPATCH(), (
5571             *(GLuint   *)(pc +  0),
5572             len,
5573              (const GLubyte *)(pc +  8),
5574             params
5575         ) );
5576         __glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0);
5577         error = Success;
5578     }
5579
5580     return error;
5581 }
5582
5583 int __glXDisp_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
5584 {
5585     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5586     int error;
5587     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5588
5589     pc += __GLX_VENDPRIV_HDR_SIZE;
5590     if ( cx != NULL ) {
5591         const GLsizei len = *(GLsizei  *)(pc +  4);
5592
5593         GLfloat params[4];
5594         CALL_GetProgramNamedParameterfvNV( GET_DISPATCH(), (
5595             *(GLuint   *)(pc +  0),
5596             len,
5597              (const GLubyte *)(pc +  8),
5598             params
5599         ) );
5600         __glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0);
5601         error = Success;
5602     }
5603
5604     return error;
5605 }
5606
5607 void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc)
5608 {
5609     const GLsizei len = *(GLsizei  *)(pc + 36);
5610
5611 #ifdef __GLX_ALIGN64
5612     const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;
5613     if ((unsigned long)(pc) & 7) {
5614         (void) memmove(pc-4, pc, cmdlen);
5615         pc -= 4;
5616     }
5617 #endif
5618
5619     CALL_ProgramNamedParameter4dvNV( GET_DISPATCH(), (
5620         *(GLuint   *)(pc + 32),
5621         len,
5622          (const GLubyte *)(pc + 40),
5623          (const GLdouble *)(pc +  0)
5624     ) );
5625 }
5626
5627 void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc)
5628 {
5629     const GLsizei len = *(GLsizei  *)(pc +  4);
5630
5631     CALL_ProgramNamedParameter4fvNV( GET_DISPATCH(), (
5632         *(GLuint   *)(pc +  0),
5633         len,
5634          (const GLubyte *)(pc + 24),
5635          (const GLfloat *)(pc +  8)
5636     ) );
5637 }
5638
5639 void __glXDisp_BlendEquationSeparateEXT(GLbyte * pc)
5640 {
5641     CALL_BlendEquationSeparateEXT( GET_DISPATCH(), (
5642         *(GLenum   *)(pc +  0),
5643         *(GLenum   *)(pc +  4)
5644     ) );
5645 }
5646
5647 void __glXDisp_BindFramebufferEXT(GLbyte * pc)
5648 {
5649     CALL_BindFramebufferEXT( GET_DISPATCH(), (
5650         *(GLenum   *)(pc +  0),
5651         *(GLuint   *)(pc +  4)
5652     ) );
5653 }
5654
5655 void __glXDisp_BindRenderbufferEXT(GLbyte * pc)
5656 {
5657     CALL_BindRenderbufferEXT( GET_DISPATCH(), (
5658         *(GLenum   *)(pc +  0),
5659         *(GLuint   *)(pc +  4)
5660     ) );
5661 }
5662
5663 int __glXDisp_CheckFramebufferStatusEXT(__GLXclientState *cl, GLbyte *pc)
5664 {
5665     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5666     int error;
5667     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5668
5669     pc += __GLX_VENDPRIV_HDR_SIZE;
5670     if ( cx != NULL ) {
5671         GLenum retval;
5672         retval = CALL_CheckFramebufferStatusEXT( GET_DISPATCH(), (
5673             *(GLenum   *)(pc +  0)
5674         ) );
5675         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5676         error = Success;
5677     }
5678
5679     return error;
5680 }
5681
5682 void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc)
5683 {
5684     const GLsizei n = *(GLsizei  *)(pc +  0);
5685
5686     CALL_DeleteFramebuffersEXT( GET_DISPATCH(), (
5687         n,
5688          (const GLuint *)(pc +  4)
5689     ) );
5690 }
5691
5692 void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc)
5693 {
5694     const GLsizei n = *(GLsizei  *)(pc +  0);
5695
5696     CALL_DeleteRenderbuffersEXT( GET_DISPATCH(), (
5697         n,
5698          (const GLuint *)(pc +  4)
5699     ) );
5700 }
5701
5702 void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc)
5703 {
5704     CALL_FramebufferRenderbufferEXT( GET_DISPATCH(), (
5705         *(GLenum   *)(pc +  0),
5706         *(GLenum   *)(pc +  4),
5707         *(GLenum   *)(pc +  8),
5708         *(GLuint   *)(pc + 12)
5709     ) );
5710 }
5711
5712 void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc)
5713 {
5714     CALL_FramebufferTexture1DEXT( GET_DISPATCH(), (
5715         *(GLenum   *)(pc +  0),
5716         *(GLenum   *)(pc +  4),
5717         *(GLenum   *)(pc +  8),
5718         *(GLuint   *)(pc + 12),
5719         *(GLint    *)(pc + 16)
5720     ) );
5721 }
5722
5723 void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc)
5724 {
5725     CALL_FramebufferTexture2DEXT( GET_DISPATCH(), (
5726         *(GLenum   *)(pc +  0),
5727         *(GLenum   *)(pc +  4),
5728         *(GLenum   *)(pc +  8),
5729         *(GLuint   *)(pc + 12),
5730         *(GLint    *)(pc + 16)
5731     ) );
5732 }
5733
5734 void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc)
5735 {
5736     CALL_FramebufferTexture3DEXT( GET_DISPATCH(), (
5737         *(GLenum   *)(pc +  0),
5738         *(GLenum   *)(pc +  4),
5739         *(GLenum   *)(pc +  8),
5740         *(GLuint   *)(pc + 12),
5741         *(GLint    *)(pc + 16),
5742         *(GLint    *)(pc + 20)
5743     ) );
5744 }
5745
5746 int __glXDisp_GenFramebuffersEXT(__GLXclientState *cl, GLbyte *pc)
5747 {
5748     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5749     int error;
5750     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5751
5752     pc += __GLX_VENDPRIV_HDR_SIZE;
5753     if ( cx != NULL ) {
5754         const GLsizei n = *(GLsizei  *)(pc +  0);
5755
5756         GLuint answerBuffer[200];
5757         GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
5758         CALL_GenFramebuffersEXT( GET_DISPATCH(), (
5759             n,
5760             framebuffers
5761         ) );
5762         __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
5763         error = Success;
5764     }
5765
5766     return error;
5767 }
5768
5769 int __glXDisp_GenRenderbuffersEXT(__GLXclientState *cl, GLbyte *pc)
5770 {
5771     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5772     int error;
5773     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5774
5775     pc += __GLX_VENDPRIV_HDR_SIZE;
5776     if ( cx != NULL ) {
5777         const GLsizei n = *(GLsizei  *)(pc +  0);
5778
5779         GLuint answerBuffer[200];
5780         GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
5781         CALL_GenRenderbuffersEXT( GET_DISPATCH(), (
5782             n,
5783             renderbuffers
5784         ) );
5785         __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
5786         error = Success;
5787     }
5788
5789     return error;
5790 }
5791
5792 void __glXDisp_GenerateMipmapEXT(GLbyte * pc)
5793 {
5794     CALL_GenerateMipmapEXT( GET_DISPATCH(), (
5795         *(GLenum   *)(pc +  0)
5796     ) );
5797 }
5798
5799 int __glXDisp_GetFramebufferAttachmentParameterivEXT(__GLXclientState *cl, GLbyte *pc)
5800 {
5801     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5802     int error;
5803     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5804
5805     pc += __GLX_VENDPRIV_HDR_SIZE;
5806     if ( cx != NULL ) {
5807         GLint params[1];
5808         CALL_GetFramebufferAttachmentParameterivEXT( GET_DISPATCH(), (
5809             *(GLenum   *)(pc +  0),
5810             *(GLenum   *)(pc +  4),
5811             *(GLenum   *)(pc +  8),
5812             params
5813         ) );
5814         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
5815         error = Success;
5816     }
5817
5818     return error;
5819 }
5820
5821 int __glXDisp_GetRenderbufferParameterivEXT(__GLXclientState *cl, GLbyte *pc)
5822 {
5823     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5824     int error;
5825     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5826
5827     pc += __GLX_VENDPRIV_HDR_SIZE;
5828     if ( cx != NULL ) {
5829         GLint params[1];
5830         CALL_GetRenderbufferParameterivEXT( GET_DISPATCH(), (
5831             *(GLenum   *)(pc +  0),
5832             *(GLenum   *)(pc +  4),
5833             params
5834         ) );
5835         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
5836         error = Success;
5837     }
5838
5839     return error;
5840 }
5841
5842 int __glXDisp_IsFramebufferEXT(__GLXclientState *cl, GLbyte *pc)
5843 {
5844     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5845     int error;
5846     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5847
5848     pc += __GLX_VENDPRIV_HDR_SIZE;
5849     if ( cx != NULL ) {
5850         GLboolean retval;
5851         retval = CALL_IsFramebufferEXT( GET_DISPATCH(), (
5852             *(GLuint   *)(pc +  0)
5853         ) );
5854         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5855         error = Success;
5856     }
5857
5858     return error;
5859 }
5860
5861 int __glXDisp_IsRenderbufferEXT(__GLXclientState *cl, GLbyte *pc)
5862 {
5863     xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
5864     int error;
5865     __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
5866
5867     pc += __GLX_VENDPRIV_HDR_SIZE;
5868     if ( cx != NULL ) {
5869         GLboolean retval;
5870         retval = CALL_IsRenderbufferEXT( GET_DISPATCH(), (
5871             *(GLuint   *)(pc +  0)
5872         ) );
5873         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5874         error = Success;
5875     }
5876
5877     return error;
5878 }
5879
5880 void __glXDisp_RenderbufferStorageEXT(GLbyte * pc)
5881 {
5882     CALL_RenderbufferStorageEXT( GET_DISPATCH(), (
5883         *(GLenum   *)(pc +  0),
5884         *(GLenum   *)(pc +  4),
5885         *(GLsizei  *)(pc +  8),
5886         *(GLsizei  *)(pc + 12)
5887     ) );
5888 }
5889