indirect_dispatch.c - xserver - xserver with xephyr scale patch

indirect_dispatch.c (131894B)
      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 <inttypes.h>
     29 #include "glxserver.h"
     30 #include "indirect_size.h"
     31 #include "indirect_size_get.h"
     32 #include "indirect_dispatch.h"
     33 #include "glxbyteorder.h"
     34 #include "indirect_util.h"
     35 #include "singlesize.h"
     36 
     37 #define __GLX_PAD(x)  (((x) + 3) & ~3)
     38 
     39 typedef struct {
     40     __GLX_PIXEL_3D_HDR;
     41 } __GLXpixel3DHeader;
     42 
     43 extern GLboolean __glXErrorOccured(void);
     44 extern void __glXClearErrorOccured(void);
     45 
     46 static const unsigned dummy_answer[2] = { 0, 0 };
     47 
     48 int
     49 __glXDisp_NewList(__GLXclientState * cl, GLbyte * pc)
     50 {
     51     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     52     int error;
     53     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
     54 
     55     pc += __GLX_SINGLE_HDR_SIZE;
     56     if (cx != NULL) {
     57         glNewList(*(GLuint *) (pc + 0), *(GLenum *) (pc + 4));
     58         error = Success;
     59     }
     60 
     61     return error;
     62 }
     63 
     64 int
     65 __glXDisp_EndList(__GLXclientState * cl, GLbyte * pc)
     66 {
     67     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     68     int error;
     69     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
     70 
     71     pc += __GLX_SINGLE_HDR_SIZE;
     72     if (cx != NULL) {
     73         glEndList();
     74         error = Success;
     75     }
     76 
     77     return error;
     78 }
     79 
     80 void
     81 __glXDisp_CallList(GLbyte * pc)
     82 {
     83     glCallList(*(GLuint *) (pc + 0));
     84 }
     85 
     86 void
     87 __glXDisp_CallLists(GLbyte * pc)
     88 {
     89     const GLsizei n = *(GLsizei *) (pc + 0);
     90     const GLenum type = *(GLenum *) (pc + 4);
     91     const GLvoid *lists = (const GLvoid *) (pc + 8);
     92 
     93     lists = (const GLvoid *) (pc + 8);
     94 
     95     glCallLists(n, type, lists);
     96 }
     97 
     98 int
     99 __glXDisp_DeleteLists(__GLXclientState * cl, GLbyte * pc)
    100 {
    101     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    102     int error;
    103     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
    104 
    105     pc += __GLX_SINGLE_HDR_SIZE;
    106     if (cx != NULL) {
    107         glDeleteLists(*(GLuint *) (pc + 0), *(GLsizei *) (pc + 4));
    108         error = Success;
    109     }
    110 
    111     return error;
    112 }
    113 
    114 int
    115 __glXDisp_GenLists(__GLXclientState * cl, GLbyte * pc)
    116 {
    117     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    118     int error;
    119     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
    120 
    121     pc += __GLX_SINGLE_HDR_SIZE;
    122     if (cx != NULL) {
    123         GLuint retval;
    124 
    125         retval = glGenLists(*(GLsizei *) (pc + 0));
    126         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
    127         error = Success;
    128     }
    129 
    130     return error;
    131 }
    132 
    133 void
    134 __glXDisp_ListBase(GLbyte * pc)
    135 {
    136     glListBase(*(GLuint *) (pc + 0));
    137 }
    138 
    139 void
    140 __glXDisp_Begin(GLbyte * pc)
    141 {
    142     glBegin(*(GLenum *) (pc + 0));
    143 }
    144 
    145 void
    146 __glXDisp_Bitmap(GLbyte * pc)
    147 {
    148     const GLubyte *const bitmap = (const GLubyte *) ((pc + 44));
    149     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
    150 
    151     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
    152     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
    153     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
    154     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
    155     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
    156 
    157     glBitmap(*(GLsizei *) (pc + 20),
    158              *(GLsizei *) (pc + 24),
    159              *(GLfloat *) (pc + 28),
    160              *(GLfloat *) (pc + 32),
    161              *(GLfloat *) (pc + 36), *(GLfloat *) (pc + 40), bitmap);
    162 }
    163 
    164 void
    165 __glXDisp_Color3bv(GLbyte * pc)
    166 {
    167     glColor3bv((const GLbyte *) (pc + 0));
    168 }
    169 
    170 void
    171 __glXDisp_Color3dv(GLbyte * pc)
    172 {
    173 #ifdef __GLX_ALIGN64
    174     if ((unsigned long) (pc) & 7) {
    175         (void) memmove(pc - 4, pc, 24);
    176         pc -= 4;
    177     }
    178 #endif
    179 
    180     glColor3dv((const GLdouble *) (pc + 0));
    181 }
    182 
    183 void
    184 __glXDisp_Color3fv(GLbyte * pc)
    185 {
    186     glColor3fv((const GLfloat *) (pc + 0));
    187 }
    188 
    189 void
    190 __glXDisp_Color3iv(GLbyte * pc)
    191 {
    192     glColor3iv((const GLint *) (pc + 0));
    193 }
    194 
    195 void
    196 __glXDisp_Color3sv(GLbyte * pc)
    197 {
    198     glColor3sv((const GLshort *) (pc + 0));
    199 }
    200 
    201 void
    202 __glXDisp_Color3ubv(GLbyte * pc)
    203 {
    204     glColor3ubv((const GLubyte *) (pc + 0));
    205 }
    206 
    207 void
    208 __glXDisp_Color3uiv(GLbyte * pc)
    209 {
    210     glColor3uiv((const GLuint *) (pc + 0));
    211 }
    212 
    213 void
    214 __glXDisp_Color3usv(GLbyte * pc)
    215 {
    216     glColor3usv((const GLushort *) (pc + 0));
    217 }
    218 
    219 void
    220 __glXDisp_Color4bv(GLbyte * pc)
    221 {
    222     glColor4bv((const GLbyte *) (pc + 0));
    223 }
    224 
    225 void
    226 __glXDisp_Color4dv(GLbyte * pc)
    227 {
    228 #ifdef __GLX_ALIGN64
    229     if ((unsigned long) (pc) & 7) {
    230         (void) memmove(pc - 4, pc, 32);
    231         pc -= 4;
    232     }
    233 #endif
    234 
    235     glColor4dv((const GLdouble *) (pc + 0));
    236 }
    237 
    238 void
    239 __glXDisp_Color4fv(GLbyte * pc)
    240 {
    241     glColor4fv((const GLfloat *) (pc + 0));
    242 }
    243 
    244 void
    245 __glXDisp_Color4iv(GLbyte * pc)
    246 {
    247     glColor4iv((const GLint *) (pc + 0));
    248 }
    249 
    250 void
    251 __glXDisp_Color4sv(GLbyte * pc)
    252 {
    253     glColor4sv((const GLshort *) (pc + 0));
    254 }
    255 
    256 void
    257 __glXDisp_Color4ubv(GLbyte * pc)
    258 {
    259     glColor4ubv((const GLubyte *) (pc + 0));
    260 }
    261 
    262 void
    263 __glXDisp_Color4uiv(GLbyte * pc)
    264 {
    265     glColor4uiv((const GLuint *) (pc + 0));
    266 }
    267 
    268 void
    269 __glXDisp_Color4usv(GLbyte * pc)
    270 {
    271     glColor4usv((const GLushort *) (pc + 0));
    272 }
    273 
    274 void
    275 __glXDisp_EdgeFlagv(GLbyte * pc)
    276 {
    277     glEdgeFlagv((const GLboolean *) (pc + 0));
    278 }
    279 
    280 void
    281 __glXDisp_End(GLbyte * pc)
    282 {
    283     glEnd();
    284 }
    285 
    286 void
    287 __glXDisp_Indexdv(GLbyte * pc)
    288 {
    289 #ifdef __GLX_ALIGN64
    290     if ((unsigned long) (pc) & 7) {
    291         (void) memmove(pc - 4, pc, 8);
    292         pc -= 4;
    293     }
    294 #endif
    295 
    296     glIndexdv((const GLdouble *) (pc + 0));
    297 }
    298 
    299 void
    300 __glXDisp_Indexfv(GLbyte * pc)
    301 {
    302     glIndexfv((const GLfloat *) (pc + 0));
    303 }
    304 
    305 void
    306 __glXDisp_Indexiv(GLbyte * pc)
    307 {
    308     glIndexiv((const GLint *) (pc + 0));
    309 }
    310 
    311 void
    312 __glXDisp_Indexsv(GLbyte * pc)
    313 {
    314     glIndexsv((const GLshort *) (pc + 0));
    315 }
    316 
    317 void
    318 __glXDisp_Normal3bv(GLbyte * pc)
    319 {
    320     glNormal3bv((const GLbyte *) (pc + 0));
    321 }
    322 
    323 void
    324 __glXDisp_Normal3dv(GLbyte * pc)
    325 {
    326 #ifdef __GLX_ALIGN64
    327     if ((unsigned long) (pc) & 7) {
    328         (void) memmove(pc - 4, pc, 24);
    329         pc -= 4;
    330     }
    331 #endif
    332 
    333     glNormal3dv((const GLdouble *) (pc + 0));
    334 }
    335 
    336 void
    337 __glXDisp_Normal3fv(GLbyte * pc)
    338 {
    339     glNormal3fv((const GLfloat *) (pc + 0));
    340 }
    341 
    342 void
    343 __glXDisp_Normal3iv(GLbyte * pc)
    344 {
    345     glNormal3iv((const GLint *) (pc + 0));
    346 }
    347 
    348 void
    349 __glXDisp_Normal3sv(GLbyte * pc)
    350 {
    351     glNormal3sv((const GLshort *) (pc + 0));
    352 }
    353 
    354 void
    355 __glXDisp_RasterPos2dv(GLbyte * pc)
    356 {
    357 #ifdef __GLX_ALIGN64
    358     if ((unsigned long) (pc) & 7) {
    359         (void) memmove(pc - 4, pc, 16);
    360         pc -= 4;
    361     }
    362 #endif
    363 
    364     glRasterPos2dv((const GLdouble *) (pc + 0));
    365 }
    366 
    367 void
    368 __glXDisp_RasterPos2fv(GLbyte * pc)
    369 {
    370     glRasterPos2fv((const GLfloat *) (pc + 0));
    371 }
    372 
    373 void
    374 __glXDisp_RasterPos2iv(GLbyte * pc)
    375 {
    376     glRasterPos2iv((const GLint *) (pc + 0));
    377 }
    378 
    379 void
    380 __glXDisp_RasterPos2sv(GLbyte * pc)
    381 {
    382     glRasterPos2sv((const GLshort *) (pc + 0));
    383 }
    384 
    385 void
    386 __glXDisp_RasterPos3dv(GLbyte * pc)
    387 {
    388 #ifdef __GLX_ALIGN64
    389     if ((unsigned long) (pc) & 7) {
    390         (void) memmove(pc - 4, pc, 24);
    391         pc -= 4;
    392     }
    393 #endif
    394 
    395     glRasterPos3dv((const GLdouble *) (pc + 0));
    396 }
    397 
    398 void
    399 __glXDisp_RasterPos3fv(GLbyte * pc)
    400 {
    401     glRasterPos3fv((const GLfloat *) (pc + 0));
    402 }
    403 
    404 void
    405 __glXDisp_RasterPos3iv(GLbyte * pc)
    406 {
    407     glRasterPos3iv((const GLint *) (pc + 0));
    408 }
    409 
    410 void
    411 __glXDisp_RasterPos3sv(GLbyte * pc)
    412 {
    413     glRasterPos3sv((const GLshort *) (pc + 0));
    414 }
    415 
    416 void
    417 __glXDisp_RasterPos4dv(GLbyte * pc)
    418 {
    419 #ifdef __GLX_ALIGN64
    420     if ((unsigned long) (pc) & 7) {
    421         (void) memmove(pc - 4, pc, 32);
    422         pc -= 4;
    423     }
    424 #endif
    425 
    426     glRasterPos4dv((const GLdouble *) (pc + 0));
    427 }
    428 
    429 void
    430 __glXDisp_RasterPos4fv(GLbyte * pc)
    431 {
    432     glRasterPos4fv((const GLfloat *) (pc + 0));
    433 }
    434 
    435 void
    436 __glXDisp_RasterPos4iv(GLbyte * pc)
    437 {
    438     glRasterPos4iv((const GLint *) (pc + 0));
    439 }
    440 
    441 void
    442 __glXDisp_RasterPos4sv(GLbyte * pc)
    443 {
    444     glRasterPos4sv((const GLshort *) (pc + 0));
    445 }
    446 
    447 void
    448 __glXDisp_Rectdv(GLbyte * pc)
    449 {
    450 #ifdef __GLX_ALIGN64
    451     if ((unsigned long) (pc) & 7) {
    452         (void) memmove(pc - 4, pc, 32);
    453         pc -= 4;
    454     }
    455 #endif
    456 
    457     glRectdv((const GLdouble *) (pc + 0), (const GLdouble *) (pc + 16));
    458 }
    459 
    460 void
    461 __glXDisp_Rectfv(GLbyte * pc)
    462 {
    463     glRectfv((const GLfloat *) (pc + 0), (const GLfloat *) (pc + 8));
    464 }
    465 
    466 void
    467 __glXDisp_Rectiv(GLbyte * pc)
    468 {
    469     glRectiv((const GLint *) (pc + 0), (const GLint *) (pc + 8));
    470 }
    471 
    472 void
    473 __glXDisp_Rectsv(GLbyte * pc)
    474 {
    475     glRectsv((const GLshort *) (pc + 0), (const GLshort *) (pc + 4));
    476 }
    477 
    478 void
    479 __glXDisp_TexCoord1dv(GLbyte * pc)
    480 {
    481 #ifdef __GLX_ALIGN64
    482     if ((unsigned long) (pc) & 7) {
    483         (void) memmove(pc - 4, pc, 8);
    484         pc -= 4;
    485     }
    486 #endif
    487 
    488     glTexCoord1dv((const GLdouble *) (pc + 0));
    489 }
    490 
    491 void
    492 __glXDisp_TexCoord1fv(GLbyte * pc)
    493 {
    494     glTexCoord1fv((const GLfloat *) (pc + 0));
    495 }
    496 
    497 void
    498 __glXDisp_TexCoord1iv(GLbyte * pc)
    499 {
    500     glTexCoord1iv((const GLint *) (pc + 0));
    501 }
    502 
    503 void
    504 __glXDisp_TexCoord1sv(GLbyte * pc)
    505 {
    506     glTexCoord1sv((const GLshort *) (pc + 0));
    507 }
    508 
    509 void
    510 __glXDisp_TexCoord2dv(GLbyte * pc)
    511 {
    512 #ifdef __GLX_ALIGN64
    513     if ((unsigned long) (pc) & 7) {
    514         (void) memmove(pc - 4, pc, 16);
    515         pc -= 4;
    516     }
    517 #endif
    518 
    519     glTexCoord2dv((const GLdouble *) (pc + 0));
    520 }
    521 
    522 void
    523 __glXDisp_TexCoord2fv(GLbyte * pc)
    524 {
    525     glTexCoord2fv((const GLfloat *) (pc + 0));
    526 }
    527 
    528 void
    529 __glXDisp_TexCoord2iv(GLbyte * pc)
    530 {
    531     glTexCoord2iv((const GLint *) (pc + 0));
    532 }
    533 
    534 void
    535 __glXDisp_TexCoord2sv(GLbyte * pc)
    536 {
    537     glTexCoord2sv((const GLshort *) (pc + 0));
    538 }
    539 
    540 void
    541 __glXDisp_TexCoord3dv(GLbyte * pc)
    542 {
    543 #ifdef __GLX_ALIGN64
    544     if ((unsigned long) (pc) & 7) {
    545         (void) memmove(pc - 4, pc, 24);
    546         pc -= 4;
    547     }
    548 #endif
    549 
    550     glTexCoord3dv((const GLdouble *) (pc + 0));
    551 }
    552 
    553 void
    554 __glXDisp_TexCoord3fv(GLbyte * pc)
    555 {
    556     glTexCoord3fv((const GLfloat *) (pc + 0));
    557 }
    558 
    559 void
    560 __glXDisp_TexCoord3iv(GLbyte * pc)
    561 {
    562     glTexCoord3iv((const GLint *) (pc + 0));
    563 }
    564 
    565 void
    566 __glXDisp_TexCoord3sv(GLbyte * pc)
    567 {
    568     glTexCoord3sv((const GLshort *) (pc + 0));
    569 }
    570 
    571 void
    572 __glXDisp_TexCoord4dv(GLbyte * pc)
    573 {
    574 #ifdef __GLX_ALIGN64
    575     if ((unsigned long) (pc) & 7) {
    576         (void) memmove(pc - 4, pc, 32);
    577         pc -= 4;
    578     }
    579 #endif
    580 
    581     glTexCoord4dv((const GLdouble *) (pc + 0));
    582 }
    583 
    584 void
    585 __glXDisp_TexCoord4fv(GLbyte * pc)
    586 {
    587     glTexCoord4fv((const GLfloat *) (pc + 0));
    588 }
    589 
    590 void
    591 __glXDisp_TexCoord4iv(GLbyte * pc)
    592 {
    593     glTexCoord4iv((const GLint *) (pc + 0));
    594 }
    595 
    596 void
    597 __glXDisp_TexCoord4sv(GLbyte * pc)
    598 {
    599     glTexCoord4sv((const GLshort *) (pc + 0));
    600 }
    601 
    602 void
    603 __glXDisp_Vertex2dv(GLbyte * pc)
    604 {
    605 #ifdef __GLX_ALIGN64
    606     if ((unsigned long) (pc) & 7) {
    607         (void) memmove(pc - 4, pc, 16);
    608         pc -= 4;
    609     }
    610 #endif
    611 
    612     glVertex2dv((const GLdouble *) (pc + 0));
    613 }
    614 
    615 void
    616 __glXDisp_Vertex2fv(GLbyte * pc)
    617 {
    618     glVertex2fv((const GLfloat *) (pc + 0));
    619 }
    620 
    621 void
    622 __glXDisp_Vertex2iv(GLbyte * pc)
    623 {
    624     glVertex2iv((const GLint *) (pc + 0));
    625 }
    626 
    627 void
    628 __glXDisp_Vertex2sv(GLbyte * pc)
    629 {
    630     glVertex2sv((const GLshort *) (pc + 0));
    631 }
    632 
    633 void
    634 __glXDisp_Vertex3dv(GLbyte * pc)
    635 {
    636 #ifdef __GLX_ALIGN64
    637     if ((unsigned long) (pc) & 7) {
    638         (void) memmove(pc - 4, pc, 24);
    639         pc -= 4;
    640     }
    641 #endif
    642 
    643     glVertex3dv((const GLdouble *) (pc + 0));
    644 }
    645 
    646 void
    647 __glXDisp_Vertex3fv(GLbyte * pc)
    648 {
    649     glVertex3fv((const GLfloat *) (pc + 0));
    650 }
    651 
    652 void
    653 __glXDisp_Vertex3iv(GLbyte * pc)
    654 {
    655     glVertex3iv((const GLint *) (pc + 0));
    656 }
    657 
    658 void
    659 __glXDisp_Vertex3sv(GLbyte * pc)
    660 {
    661     glVertex3sv((const GLshort *) (pc + 0));
    662 }
    663 
    664 void
    665 __glXDisp_Vertex4dv(GLbyte * pc)
    666 {
    667 #ifdef __GLX_ALIGN64
    668     if ((unsigned long) (pc) & 7) {
    669         (void) memmove(pc - 4, pc, 32);
    670         pc -= 4;
    671     }
    672 #endif
    673 
    674     glVertex4dv((const GLdouble *) (pc + 0));
    675 }
    676 
    677 void
    678 __glXDisp_Vertex4fv(GLbyte * pc)
    679 {
    680     glVertex4fv((const GLfloat *) (pc + 0));
    681 }
    682 
    683 void
    684 __glXDisp_Vertex4iv(GLbyte * pc)
    685 {
    686     glVertex4iv((const GLint *) (pc + 0));
    687 }
    688 
    689 void
    690 __glXDisp_Vertex4sv(GLbyte * pc)
    691 {
    692     glVertex4sv((const GLshort *) (pc + 0));
    693 }
    694 
    695 void
    696 __glXDisp_ClipPlane(GLbyte * pc)
    697 {
    698 #ifdef __GLX_ALIGN64
    699     if ((unsigned long) (pc) & 7) {
    700         (void) memmove(pc - 4, pc, 36);
    701         pc -= 4;
    702     }
    703 #endif
    704 
    705     glClipPlane(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0));
    706 }
    707 
    708 void
    709 __glXDisp_ColorMaterial(GLbyte * pc)
    710 {
    711     glColorMaterial(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
    712 }
    713 
    714 void
    715 __glXDisp_CullFace(GLbyte * pc)
    716 {
    717     glCullFace(*(GLenum *) (pc + 0));
    718 }
    719 
    720 void
    721 __glXDisp_Fogf(GLbyte * pc)
    722 {
    723     glFogf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
    724 }
    725 
    726 void
    727 __glXDisp_Fogfv(GLbyte * pc)
    728 {
    729     const GLenum pname = *(GLenum *) (pc + 0);
    730     const GLfloat *params;
    731 
    732     params = (const GLfloat *) (pc + 4);
    733 
    734     glFogfv(pname, params);
    735 }
    736 
    737 void
    738 __glXDisp_Fogi(GLbyte * pc)
    739 {
    740     glFogi(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
    741 }
    742 
    743 void
    744 __glXDisp_Fogiv(GLbyte * pc)
    745 {
    746     const GLenum pname = *(GLenum *) (pc + 0);
    747     const GLint *params;
    748 
    749     params = (const GLint *) (pc + 4);
    750 
    751     glFogiv(pname, params);
    752 }
    753 
    754 void
    755 __glXDisp_FrontFace(GLbyte * pc)
    756 {
    757     glFrontFace(*(GLenum *) (pc + 0));
    758 }
    759 
    760 void
    761 __glXDisp_Hint(GLbyte * pc)
    762 {
    763     glHint(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
    764 }
    765 
    766 void
    767 __glXDisp_Lightf(GLbyte * pc)
    768 {
    769     glLightf(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
    770 }
    771 
    772 void
    773 __glXDisp_Lightfv(GLbyte * pc)
    774 {
    775     const GLenum pname = *(GLenum *) (pc + 4);
    776     const GLfloat *params;
    777 
    778     params = (const GLfloat *) (pc + 8);
    779 
    780     glLightfv(*(GLenum *) (pc + 0), pname, params);
    781 }
    782 
    783 void
    784 __glXDisp_Lighti(GLbyte * pc)
    785 {
    786     glLighti(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
    787 }
    788 
    789 void
    790 __glXDisp_Lightiv(GLbyte * pc)
    791 {
    792     const GLenum pname = *(GLenum *) (pc + 4);
    793     const GLint *params;
    794 
    795     params = (const GLint *) (pc + 8);
    796 
    797     glLightiv(*(GLenum *) (pc + 0), pname, params);
    798 }
    799 
    800 void
    801 __glXDisp_LightModelf(GLbyte * pc)
    802 {
    803     glLightModelf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
    804 }
    805 
    806 void
    807 __glXDisp_LightModelfv(GLbyte * pc)
    808 {
    809     const GLenum pname = *(GLenum *) (pc + 0);
    810     const GLfloat *params;
    811 
    812     params = (const GLfloat *) (pc + 4);
    813 
    814     glLightModelfv(pname, params);
    815 }
    816 
    817 void
    818 __glXDisp_LightModeli(GLbyte * pc)
    819 {
    820     glLightModeli(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
    821 }
    822 
    823 void
    824 __glXDisp_LightModeliv(GLbyte * pc)
    825 {
    826     const GLenum pname = *(GLenum *) (pc + 0);
    827     const GLint *params;
    828 
    829     params = (const GLint *) (pc + 4);
    830 
    831     glLightModeliv(pname, params);
    832 }
    833 
    834 void
    835 __glXDisp_LineStipple(GLbyte * pc)
    836 {
    837     glLineStipple(*(GLint *) (pc + 0), *(GLushort *) (pc + 4));
    838 }
    839 
    840 void
    841 __glXDisp_LineWidth(GLbyte * pc)
    842 {
    843     glLineWidth(*(GLfloat *) (pc + 0));
    844 }
    845 
    846 void
    847 __glXDisp_Materialf(GLbyte * pc)
    848 {
    849     glMaterialf(*(GLenum *) (pc + 0),
    850                 *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
    851 }
    852 
    853 void
    854 __glXDisp_Materialfv(GLbyte * pc)
    855 {
    856     const GLenum pname = *(GLenum *) (pc + 4);
    857     const GLfloat *params;
    858 
    859     params = (const GLfloat *) (pc + 8);
    860 
    861     glMaterialfv(*(GLenum *) (pc + 0), pname, params);
    862 }
    863 
    864 void
    865 __glXDisp_Materiali(GLbyte * pc)
    866 {
    867     glMateriali(*(GLenum *) (pc + 0),
    868                 *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
    869 }
    870 
    871 void
    872 __glXDisp_Materialiv(GLbyte * pc)
    873 {
    874     const GLenum pname = *(GLenum *) (pc + 4);
    875     const GLint *params;
    876 
    877     params = (const GLint *) (pc + 8);
    878 
    879     glMaterialiv(*(GLenum *) (pc + 0), pname, params);
    880 }
    881 
    882 void
    883 __glXDisp_PointSize(GLbyte * pc)
    884 {
    885     glPointSize(*(GLfloat *) (pc + 0));
    886 }
    887 
    888 void
    889 __glXDisp_PolygonMode(GLbyte * pc)
    890 {
    891     glPolygonMode(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
    892 }
    893 
    894 void
    895 __glXDisp_PolygonStipple(GLbyte * pc)
    896 {
    897     const GLubyte *const mask = (const GLubyte *) ((pc + 20));
    898     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
    899 
    900     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
    901     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
    902     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
    903     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
    904     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
    905 
    906     glPolygonStipple(mask);
    907 }
    908 
    909 void
    910 __glXDisp_Scissor(GLbyte * pc)
    911 {
    912     glScissor(*(GLint *) (pc + 0),
    913               *(GLint *) (pc + 4),
    914               *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
    915 }
    916 
    917 void
    918 __glXDisp_ShadeModel(GLbyte * pc)
    919 {
    920     glShadeModel(*(GLenum *) (pc + 0));
    921 }
    922 
    923 void
    924 __glXDisp_TexParameterf(GLbyte * pc)
    925 {
    926     glTexParameterf(*(GLenum *) (pc + 0),
    927                     *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
    928 }
    929 
    930 void
    931 __glXDisp_TexParameterfv(GLbyte * pc)
    932 {
    933     const GLenum pname = *(GLenum *) (pc + 4);
    934     const GLfloat *params;
    935 
    936     params = (const GLfloat *) (pc + 8);
    937 
    938     glTexParameterfv(*(GLenum *) (pc + 0), pname, params);
    939 }
    940 
    941 void
    942 __glXDisp_TexParameteri(GLbyte * pc)
    943 {
    944     glTexParameteri(*(GLenum *) (pc + 0),
    945                     *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
    946 }
    947 
    948 void
    949 __glXDisp_TexParameteriv(GLbyte * pc)
    950 {
    951     const GLenum pname = *(GLenum *) (pc + 4);
    952     const GLint *params;
    953 
    954     params = (const GLint *) (pc + 8);
    955 
    956     glTexParameteriv(*(GLenum *) (pc + 0), pname, params);
    957 }
    958 
    959 void
    960 __glXDisp_TexImage1D(GLbyte * pc)
    961 {
    962     const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
    963     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
    964 
    965     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
    966     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
    967     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
    968     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
    969     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
    970     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
    971 
    972     glTexImage1D(*(GLenum *) (pc + 20),
    973                  *(GLint *) (pc + 24),
    974                  *(GLint *) (pc + 28),
    975                  *(GLsizei *) (pc + 32),
    976                  *(GLint *) (pc + 40),
    977                  *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
    978 }
    979 
    980 void
    981 __glXDisp_TexImage2D(GLbyte * pc)
    982 {
    983     const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
    984     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
    985 
    986     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
    987     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
    988     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
    989     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
    990     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
    991     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
    992 
    993     glTexImage2D(*(GLenum *) (pc + 20),
    994                  *(GLint *) (pc + 24),
    995                  *(GLint *) (pc + 28),
    996                  *(GLsizei *) (pc + 32),
    997                  *(GLsizei *) (pc + 36),
    998                  *(GLint *) (pc + 40),
    999                  *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
   1000 }
   1001 
   1002 void
   1003 __glXDisp_TexEnvf(GLbyte * pc)
   1004 {
   1005     glTexEnvf(*(GLenum *) (pc + 0),
   1006               *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
   1007 }
   1008 
   1009 void
   1010 __glXDisp_TexEnvfv(GLbyte * pc)
   1011 {
   1012     const GLenum pname = *(GLenum *) (pc + 4);
   1013     const GLfloat *params;
   1014 
   1015     params = (const GLfloat *) (pc + 8);
   1016 
   1017     glTexEnvfv(*(GLenum *) (pc + 0), pname, params);
   1018 }
   1019 
   1020 void
   1021 __glXDisp_TexEnvi(GLbyte * pc)
   1022 {
   1023     glTexEnvi(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
   1024 }
   1025 
   1026 void
   1027 __glXDisp_TexEnviv(GLbyte * pc)
   1028 {
   1029     const GLenum pname = *(GLenum *) (pc + 4);
   1030     const GLint *params;
   1031 
   1032     params = (const GLint *) (pc + 8);
   1033 
   1034     glTexEnviv(*(GLenum *) (pc + 0), pname, params);
   1035 }
   1036 
   1037 void
   1038 __glXDisp_TexGend(GLbyte * pc)
   1039 {
   1040 #ifdef __GLX_ALIGN64
   1041     if ((unsigned long) (pc) & 7) {
   1042         (void) memmove(pc - 4, pc, 16);
   1043         pc -= 4;
   1044     }
   1045 #endif
   1046 
   1047     glTexGend(*(GLenum *) (pc + 8),
   1048               *(GLenum *) (pc + 12), *(GLdouble *) (pc + 0));
   1049 }
   1050 
   1051 void
   1052 __glXDisp_TexGendv(GLbyte * pc)
   1053 {
   1054     const GLenum pname = *(GLenum *) (pc + 4);
   1055     const GLdouble *params;
   1056 
   1057 #ifdef __GLX_ALIGN64
   1058     const GLuint compsize = __glTexGendv_size(pname);
   1059     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
   1060 
   1061     if ((unsigned long) (pc) & 7) {
   1062         (void) memmove(pc - 4, pc, cmdlen);
   1063         pc -= 4;
   1064     }
   1065 #endif
   1066 
   1067     params = (const GLdouble *) (pc + 8);
   1068 
   1069     glTexGendv(*(GLenum *) (pc + 0), pname, params);
   1070 }
   1071 
   1072 void
   1073 __glXDisp_TexGenf(GLbyte * pc)
   1074 {
   1075     glTexGenf(*(GLenum *) (pc + 0),
   1076               *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
   1077 }
   1078 
   1079 void
   1080 __glXDisp_TexGenfv(GLbyte * pc)
   1081 {
   1082     const GLenum pname = *(GLenum *) (pc + 4);
   1083     const GLfloat *params;
   1084 
   1085     params = (const GLfloat *) (pc + 8);
   1086 
   1087     glTexGenfv(*(GLenum *) (pc + 0), pname, params);
   1088 }
   1089 
   1090 void
   1091 __glXDisp_TexGeni(GLbyte * pc)
   1092 {
   1093     glTexGeni(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
   1094 }
   1095 
   1096 void
   1097 __glXDisp_TexGeniv(GLbyte * pc)
   1098 {
   1099     const GLenum pname = *(GLenum *) (pc + 4);
   1100     const GLint *params;
   1101 
   1102     params = (const GLint *) (pc + 8);
   1103 
   1104     glTexGeniv(*(GLenum *) (pc + 0), pname, params);
   1105 }
   1106 
   1107 void
   1108 __glXDisp_InitNames(GLbyte * pc)
   1109 {
   1110     glInitNames();
   1111 }
   1112 
   1113 void
   1114 __glXDisp_LoadName(GLbyte * pc)
   1115 {
   1116     glLoadName(*(GLuint *) (pc + 0));
   1117 }
   1118 
   1119 void
   1120 __glXDisp_PassThrough(GLbyte * pc)
   1121 {
   1122     glPassThrough(*(GLfloat *) (pc + 0));
   1123 }
   1124 
   1125 void
   1126 __glXDisp_PopName(GLbyte * pc)
   1127 {
   1128     glPopName();
   1129 }
   1130 
   1131 void
   1132 __glXDisp_PushName(GLbyte * pc)
   1133 {
   1134     glPushName(*(GLuint *) (pc + 0));
   1135 }
   1136 
   1137 void
   1138 __glXDisp_DrawBuffer(GLbyte * pc)
   1139 {
   1140     glDrawBuffer(*(GLenum *) (pc + 0));
   1141 }
   1142 
   1143 void
   1144 __glXDisp_Clear(GLbyte * pc)
   1145 {
   1146     glClear(*(GLbitfield *) (pc + 0));
   1147 }
   1148 
   1149 void
   1150 __glXDisp_ClearAccum(GLbyte * pc)
   1151 {
   1152     glClearAccum(*(GLfloat *) (pc + 0),
   1153                  *(GLfloat *) (pc + 4),
   1154                  *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12));
   1155 }
   1156 
   1157 void
   1158 __glXDisp_ClearIndex(GLbyte * pc)
   1159 {
   1160     glClearIndex(*(GLfloat *) (pc + 0));
   1161 }
   1162 
   1163 void
   1164 __glXDisp_ClearColor(GLbyte * pc)
   1165 {
   1166     glClearColor(*(GLclampf *) (pc + 0),
   1167                  *(GLclampf *) (pc + 4),
   1168                  *(GLclampf *) (pc + 8), *(GLclampf *) (pc + 12));
   1169 }
   1170 
   1171 void
   1172 __glXDisp_ClearStencil(GLbyte * pc)
   1173 {
   1174     glClearStencil(*(GLint *) (pc + 0));
   1175 }
   1176 
   1177 void
   1178 __glXDisp_ClearDepth(GLbyte * pc)
   1179 {
   1180 #ifdef __GLX_ALIGN64
   1181     if ((unsigned long) (pc) & 7) {
   1182         (void) memmove(pc - 4, pc, 8);
   1183         pc -= 4;
   1184     }
   1185 #endif
   1186 
   1187     glClearDepth(*(GLclampd *) (pc + 0));
   1188 }
   1189 
   1190 void
   1191 __glXDisp_StencilMask(GLbyte * pc)
   1192 {
   1193     glStencilMask(*(GLuint *) (pc + 0));
   1194 }
   1195 
   1196 void
   1197 __glXDisp_ColorMask(GLbyte * pc)
   1198 {
   1199     glColorMask(*(GLboolean *) (pc + 0),
   1200                 *(GLboolean *) (pc + 1),
   1201                 *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3));
   1202 }
   1203 
   1204 void
   1205 __glXDisp_DepthMask(GLbyte * pc)
   1206 {
   1207     glDepthMask(*(GLboolean *) (pc + 0));
   1208 }
   1209 
   1210 void
   1211 __glXDisp_IndexMask(GLbyte * pc)
   1212 {
   1213     glIndexMask(*(GLuint *) (pc + 0));
   1214 }
   1215 
   1216 void
   1217 __glXDisp_Accum(GLbyte * pc)
   1218 {
   1219     glAccum(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
   1220 }
   1221 
   1222 void
   1223 __glXDisp_Disable(GLbyte * pc)
   1224 {
   1225     glDisable(*(GLenum *) (pc + 0));
   1226 }
   1227 
   1228 void
   1229 __glXDisp_Enable(GLbyte * pc)
   1230 {
   1231     glEnable(*(GLenum *) (pc + 0));
   1232 }
   1233 
   1234 void
   1235 __glXDisp_PopAttrib(GLbyte * pc)
   1236 {
   1237     glPopAttrib();
   1238 }
   1239 
   1240 void
   1241 __glXDisp_PushAttrib(GLbyte * pc)
   1242 {
   1243     glPushAttrib(*(GLbitfield *) (pc + 0));
   1244 }
   1245 
   1246 void
   1247 __glXDisp_MapGrid1d(GLbyte * pc)
   1248 {
   1249 #ifdef __GLX_ALIGN64
   1250     if ((unsigned long) (pc) & 7) {
   1251         (void) memmove(pc - 4, pc, 20);
   1252         pc -= 4;
   1253     }
   1254 #endif
   1255 
   1256     glMapGrid1d(*(GLint *) (pc + 16),
   1257                 *(GLdouble *) (pc + 0), *(GLdouble *) (pc + 8));
   1258 }
   1259 
   1260 void
   1261 __glXDisp_MapGrid1f(GLbyte * pc)
   1262 {
   1263     glMapGrid1f(*(GLint *) (pc + 0),
   1264                 *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8));
   1265 }
   1266 
   1267 void
   1268 __glXDisp_MapGrid2d(GLbyte * pc)
   1269 {
   1270 #ifdef __GLX_ALIGN64
   1271     if ((unsigned long) (pc) & 7) {
   1272         (void) memmove(pc - 4, pc, 40);
   1273         pc -= 4;
   1274     }
   1275 #endif
   1276 
   1277     glMapGrid2d(*(GLint *) (pc + 32),
   1278                 *(GLdouble *) (pc + 0),
   1279                 *(GLdouble *) (pc + 8),
   1280                 *(GLint *) (pc + 36),
   1281                 *(GLdouble *) (pc + 16), *(GLdouble *) (pc + 24));
   1282 }
   1283 
   1284 void
   1285 __glXDisp_MapGrid2f(GLbyte * pc)
   1286 {
   1287     glMapGrid2f(*(GLint *) (pc + 0),
   1288                 *(GLfloat *) (pc + 4),
   1289                 *(GLfloat *) (pc + 8),
   1290                 *(GLint *) (pc + 12),
   1291                 *(GLfloat *) (pc + 16), *(GLfloat *) (pc + 20));
   1292 }
   1293 
   1294 void
   1295 __glXDisp_EvalCoord1dv(GLbyte * pc)
   1296 {
   1297 #ifdef __GLX_ALIGN64
   1298     if ((unsigned long) (pc) & 7) {
   1299         (void) memmove(pc - 4, pc, 8);
   1300         pc -= 4;
   1301     }
   1302 #endif
   1303 
   1304     glEvalCoord1dv((const GLdouble *) (pc + 0));
   1305 }
   1306 
   1307 void
   1308 __glXDisp_EvalCoord1fv(GLbyte * pc)
   1309 {
   1310     glEvalCoord1fv((const GLfloat *) (pc + 0));
   1311 }
   1312 
   1313 void
   1314 __glXDisp_EvalCoord2dv(GLbyte * pc)
   1315 {
   1316 #ifdef __GLX_ALIGN64
   1317     if ((unsigned long) (pc) & 7) {
   1318         (void) memmove(pc - 4, pc, 16);
   1319         pc -= 4;
   1320     }
   1321 #endif
   1322 
   1323     glEvalCoord2dv((const GLdouble *) (pc + 0));
   1324 }
   1325 
   1326 void
   1327 __glXDisp_EvalCoord2fv(GLbyte * pc)
   1328 {
   1329     glEvalCoord2fv((const GLfloat *) (pc + 0));
   1330 }
   1331 
   1332 void
   1333 __glXDisp_EvalMesh1(GLbyte * pc)
   1334 {
   1335     glEvalMesh1(*(GLenum *) (pc + 0), *(GLint *) (pc + 4), *(GLint *) (pc + 8));
   1336 }
   1337 
   1338 void
   1339 __glXDisp_EvalPoint1(GLbyte * pc)
   1340 {
   1341     glEvalPoint1(*(GLint *) (pc + 0));
   1342 }
   1343 
   1344 void
   1345 __glXDisp_EvalMesh2(GLbyte * pc)
   1346 {
   1347     glEvalMesh2(*(GLenum *) (pc + 0),
   1348                 *(GLint *) (pc + 4),
   1349                 *(GLint *) (pc + 8),
   1350                 *(GLint *) (pc + 12), *(GLint *) (pc + 16));
   1351 }
   1352 
   1353 void
   1354 __glXDisp_EvalPoint2(GLbyte * pc)
   1355 {
   1356     glEvalPoint2(*(GLint *) (pc + 0), *(GLint *) (pc + 4));
   1357 }
   1358 
   1359 void
   1360 __glXDisp_AlphaFunc(GLbyte * pc)
   1361 {
   1362     glAlphaFunc(*(GLenum *) (pc + 0), *(GLclampf *) (pc + 4));
   1363 }
   1364 
   1365 void
   1366 __glXDisp_BlendFunc(GLbyte * pc)
   1367 {
   1368     glBlendFunc(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
   1369 }
   1370 
   1371 void
   1372 __glXDisp_LogicOp(GLbyte * pc)
   1373 {
   1374     glLogicOp(*(GLenum *) (pc + 0));
   1375 }
   1376 
   1377 void
   1378 __glXDisp_StencilFunc(GLbyte * pc)
   1379 {
   1380     glStencilFunc(*(GLenum *) (pc + 0),
   1381                   *(GLint *) (pc + 4), *(GLuint *) (pc + 8));
   1382 }
   1383 
   1384 void
   1385 __glXDisp_StencilOp(GLbyte * pc)
   1386 {
   1387     glStencilOp(*(GLenum *) (pc + 0),
   1388                 *(GLenum *) (pc + 4), *(GLenum *) (pc + 8));
   1389 }
   1390 
   1391 void
   1392 __glXDisp_DepthFunc(GLbyte * pc)
   1393 {
   1394     glDepthFunc(*(GLenum *) (pc + 0));
   1395 }
   1396 
   1397 void
   1398 __glXDisp_PixelZoom(GLbyte * pc)
   1399 {
   1400     glPixelZoom(*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4));
   1401 }
   1402 
   1403 void
   1404 __glXDisp_PixelTransferf(GLbyte * pc)
   1405 {
   1406     glPixelTransferf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
   1407 }
   1408 
   1409 void
   1410 __glXDisp_PixelTransferi(GLbyte * pc)
   1411 {
   1412     glPixelTransferi(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
   1413 }
   1414 
   1415 int
   1416 __glXDisp_PixelStoref(__GLXclientState * cl, GLbyte * pc)
   1417 {
   1418     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1419     int error;
   1420     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1421 
   1422     pc += __GLX_SINGLE_HDR_SIZE;
   1423     if (cx != NULL) {
   1424         glPixelStoref(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
   1425         error = Success;
   1426     }
   1427 
   1428     return error;
   1429 }
   1430 
   1431 int
   1432 __glXDisp_PixelStorei(__GLXclientState * cl, GLbyte * pc)
   1433 {
   1434     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1435     int error;
   1436     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1437 
   1438     pc += __GLX_SINGLE_HDR_SIZE;
   1439     if (cx != NULL) {
   1440         glPixelStorei(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
   1441         error = Success;
   1442     }
   1443 
   1444     return error;
   1445 }
   1446 
   1447 void
   1448 __glXDisp_PixelMapfv(GLbyte * pc)
   1449 {
   1450     const GLsizei mapsize = *(GLsizei *) (pc + 4);
   1451 
   1452     glPixelMapfv(*(GLenum *) (pc + 0), mapsize, (const GLfloat *) (pc + 8));
   1453 }
   1454 
   1455 void
   1456 __glXDisp_PixelMapuiv(GLbyte * pc)
   1457 {
   1458     const GLsizei mapsize = *(GLsizei *) (pc + 4);
   1459 
   1460     glPixelMapuiv(*(GLenum *) (pc + 0), mapsize, (const GLuint *) (pc + 8));
   1461 }
   1462 
   1463 void
   1464 __glXDisp_PixelMapusv(GLbyte * pc)
   1465 {
   1466     const GLsizei mapsize = *(GLsizei *) (pc + 4);
   1467 
   1468     glPixelMapusv(*(GLenum *) (pc + 0), mapsize, (const GLushort *) (pc + 8));
   1469 }
   1470 
   1471 void
   1472 __glXDisp_ReadBuffer(GLbyte * pc)
   1473 {
   1474     glReadBuffer(*(GLenum *) (pc + 0));
   1475 }
   1476 
   1477 void
   1478 __glXDisp_CopyPixels(GLbyte * pc)
   1479 {
   1480     glCopyPixels(*(GLint *) (pc + 0),
   1481                  *(GLint *) (pc + 4),
   1482                  *(GLsizei *) (pc + 8),
   1483                  *(GLsizei *) (pc + 12), *(GLenum *) (pc + 16));
   1484 }
   1485 
   1486 void
   1487 __glXDisp_DrawPixels(GLbyte * pc)
   1488 {
   1489     const GLvoid *const pixels = (const GLvoid *) ((pc + 36));
   1490     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   1491 
   1492     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   1493     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   1494     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   1495     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   1496     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   1497     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   1498 
   1499     glDrawPixels(*(GLsizei *) (pc + 20),
   1500                  *(GLsizei *) (pc + 24),
   1501                  *(GLenum *) (pc + 28), *(GLenum *) (pc + 32), pixels);
   1502 }
   1503 
   1504 int
   1505 __glXDisp_GetBooleanv(__GLXclientState * cl, GLbyte * pc)
   1506 {
   1507     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1508     int error;
   1509     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1510 
   1511     pc += __GLX_SINGLE_HDR_SIZE;
   1512     if (cx != NULL) {
   1513         const GLenum pname = *(GLenum *) (pc + 0);
   1514 
   1515         const GLuint compsize = __glGetBooleanv_size(pname);
   1516         GLboolean answerBuffer[200];
   1517         GLboolean *params =
   1518             __glXGetAnswerBuffer(cl, compsize, answerBuffer,
   1519                                  sizeof(answerBuffer), 1);
   1520 
   1521         if (params == NULL)
   1522             return BadAlloc;
   1523         __glXClearErrorOccured();
   1524 
   1525         glGetBooleanv(pname, params);
   1526         __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
   1527         error = Success;
   1528     }
   1529 
   1530     return error;
   1531 }
   1532 
   1533 int
   1534 __glXDisp_GetClipPlane(__GLXclientState * cl, GLbyte * pc)
   1535 {
   1536     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1537     int error;
   1538     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1539 
   1540     pc += __GLX_SINGLE_HDR_SIZE;
   1541     if (cx != NULL) {
   1542         GLdouble equation[4];
   1543 
   1544         glGetClipPlane(*(GLenum *) (pc + 0), equation);
   1545         __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
   1546         error = Success;
   1547     }
   1548 
   1549     return error;
   1550 }
   1551 
   1552 int
   1553 __glXDisp_GetDoublev(__GLXclientState * cl, GLbyte * pc)
   1554 {
   1555     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1556     int error;
   1557     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1558 
   1559     pc += __GLX_SINGLE_HDR_SIZE;
   1560     if (cx != NULL) {
   1561         const GLenum pname = *(GLenum *) (pc + 0);
   1562 
   1563         const GLuint compsize = __glGetDoublev_size(pname);
   1564         GLdouble answerBuffer[200];
   1565         GLdouble *params =
   1566             __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
   1567                                  sizeof(answerBuffer), 8);
   1568 
   1569         if (params == NULL)
   1570             return BadAlloc;
   1571         __glXClearErrorOccured();
   1572 
   1573         glGetDoublev(pname, params);
   1574         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
   1575         error = Success;
   1576     }
   1577 
   1578     return error;
   1579 }
   1580 
   1581 int
   1582 __glXDisp_GetError(__GLXclientState * cl, GLbyte * pc)
   1583 {
   1584     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1585     int error;
   1586     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1587 
   1588     pc += __GLX_SINGLE_HDR_SIZE;
   1589     if (cx != NULL) {
   1590         GLenum retval;
   1591 
   1592         retval = glGetError();
   1593         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   1594         error = Success;
   1595     }
   1596 
   1597     return error;
   1598 }
   1599 
   1600 int
   1601 __glXDisp_GetFloatv(__GLXclientState * cl, GLbyte * pc)
   1602 {
   1603     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1604     int error;
   1605     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1606 
   1607     pc += __GLX_SINGLE_HDR_SIZE;
   1608     if (cx != NULL) {
   1609         const GLenum pname = *(GLenum *) (pc + 0);
   1610 
   1611         const GLuint compsize = __glGetFloatv_size(pname);
   1612         GLfloat answerBuffer[200];
   1613         GLfloat *params =
   1614             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1615                                  sizeof(answerBuffer), 4);
   1616 
   1617         if (params == NULL)
   1618             return BadAlloc;
   1619         __glXClearErrorOccured();
   1620 
   1621         glGetFloatv(pname, params);
   1622         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1623         error = Success;
   1624     }
   1625 
   1626     return error;
   1627 }
   1628 
   1629 int
   1630 __glXDisp_GetIntegerv(__GLXclientState * cl, GLbyte * pc)
   1631 {
   1632     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1633     int error;
   1634     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1635 
   1636     pc += __GLX_SINGLE_HDR_SIZE;
   1637     if (cx != NULL) {
   1638         const GLenum pname = *(GLenum *) (pc + 0);
   1639 
   1640         const GLuint compsize = __glGetIntegerv_size(pname);
   1641         GLint answerBuffer[200];
   1642         GLint *params =
   1643             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1644                                  sizeof(answerBuffer), 4);
   1645 
   1646         if (params == NULL)
   1647             return BadAlloc;
   1648         __glXClearErrorOccured();
   1649 
   1650         glGetIntegerv(pname, params);
   1651         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1652         error = Success;
   1653     }
   1654 
   1655     return error;
   1656 }
   1657 
   1658 int
   1659 __glXDisp_GetLightfv(__GLXclientState * cl, GLbyte * pc)
   1660 {
   1661     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1662     int error;
   1663     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1664 
   1665     pc += __GLX_SINGLE_HDR_SIZE;
   1666     if (cx != NULL) {
   1667         const GLenum pname = *(GLenum *) (pc + 4);
   1668 
   1669         const GLuint compsize = __glGetLightfv_size(pname);
   1670         GLfloat answerBuffer[200];
   1671         GLfloat *params =
   1672             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1673                                  sizeof(answerBuffer), 4);
   1674 
   1675         if (params == NULL)
   1676             return BadAlloc;
   1677         __glXClearErrorOccured();
   1678 
   1679         glGetLightfv(*(GLenum *) (pc + 0), pname, params);
   1680         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1681         error = Success;
   1682     }
   1683 
   1684     return error;
   1685 }
   1686 
   1687 int
   1688 __glXDisp_GetLightiv(__GLXclientState * cl, GLbyte * pc)
   1689 {
   1690     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1691     int error;
   1692     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1693 
   1694     pc += __GLX_SINGLE_HDR_SIZE;
   1695     if (cx != NULL) {
   1696         const GLenum pname = *(GLenum *) (pc + 4);
   1697 
   1698         const GLuint compsize = __glGetLightiv_size(pname);
   1699         GLint answerBuffer[200];
   1700         GLint *params =
   1701             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1702                                  sizeof(answerBuffer), 4);
   1703 
   1704         if (params == NULL)
   1705             return BadAlloc;
   1706         __glXClearErrorOccured();
   1707 
   1708         glGetLightiv(*(GLenum *) (pc + 0), pname, params);
   1709         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1710         error = Success;
   1711     }
   1712 
   1713     return error;
   1714 }
   1715 
   1716 int
   1717 __glXDisp_GetMapdv(__GLXclientState * cl, GLbyte * pc)
   1718 {
   1719     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1720     int error;
   1721     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1722 
   1723     pc += __GLX_SINGLE_HDR_SIZE;
   1724     if (cx != NULL) {
   1725         const GLenum target = *(GLenum *) (pc + 0);
   1726         const GLenum query = *(GLenum *) (pc + 4);
   1727 
   1728         const GLuint compsize = __glGetMapdv_size(target, query);
   1729         GLdouble answerBuffer[200];
   1730         GLdouble *v =
   1731             __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
   1732                                  sizeof(answerBuffer), 8);
   1733 
   1734         if (v == NULL)
   1735             return BadAlloc;
   1736         __glXClearErrorOccured();
   1737 
   1738         glGetMapdv(target, query, v);
   1739         __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
   1740         error = Success;
   1741     }
   1742 
   1743     return error;
   1744 }
   1745 
   1746 int
   1747 __glXDisp_GetMapfv(__GLXclientState * cl, GLbyte * pc)
   1748 {
   1749     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1750     int error;
   1751     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1752 
   1753     pc += __GLX_SINGLE_HDR_SIZE;
   1754     if (cx != NULL) {
   1755         const GLenum target = *(GLenum *) (pc + 0);
   1756         const GLenum query = *(GLenum *) (pc + 4);
   1757 
   1758         const GLuint compsize = __glGetMapfv_size(target, query);
   1759         GLfloat answerBuffer[200];
   1760         GLfloat *v =
   1761             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1762                                  sizeof(answerBuffer), 4);
   1763 
   1764         if (v == NULL)
   1765             return BadAlloc;
   1766         __glXClearErrorOccured();
   1767 
   1768         glGetMapfv(target, query, v);
   1769         __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
   1770         error = Success;
   1771     }
   1772 
   1773     return error;
   1774 }
   1775 
   1776 int
   1777 __glXDisp_GetMapiv(__GLXclientState * cl, GLbyte * pc)
   1778 {
   1779     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1780     int error;
   1781     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1782 
   1783     pc += __GLX_SINGLE_HDR_SIZE;
   1784     if (cx != NULL) {
   1785         const GLenum target = *(GLenum *) (pc + 0);
   1786         const GLenum query = *(GLenum *) (pc + 4);
   1787 
   1788         const GLuint compsize = __glGetMapiv_size(target, query);
   1789         GLint answerBuffer[200];
   1790         GLint *v =
   1791             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1792                                  sizeof(answerBuffer), 4);
   1793 
   1794         if (v == NULL)
   1795             return BadAlloc;
   1796         __glXClearErrorOccured();
   1797 
   1798         glGetMapiv(target, query, v);
   1799         __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
   1800         error = Success;
   1801     }
   1802 
   1803     return error;
   1804 }
   1805 
   1806 int
   1807 __glXDisp_GetMaterialfv(__GLXclientState * cl, GLbyte * pc)
   1808 {
   1809     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1810     int error;
   1811     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1812 
   1813     pc += __GLX_SINGLE_HDR_SIZE;
   1814     if (cx != NULL) {
   1815         const GLenum pname = *(GLenum *) (pc + 4);
   1816 
   1817         const GLuint compsize = __glGetMaterialfv_size(pname);
   1818         GLfloat answerBuffer[200];
   1819         GLfloat *params =
   1820             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1821                                  sizeof(answerBuffer), 4);
   1822 
   1823         if (params == NULL)
   1824             return BadAlloc;
   1825         __glXClearErrorOccured();
   1826 
   1827         glGetMaterialfv(*(GLenum *) (pc + 0), pname, params);
   1828         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1829         error = Success;
   1830     }
   1831 
   1832     return error;
   1833 }
   1834 
   1835 int
   1836 __glXDisp_GetMaterialiv(__GLXclientState * cl, GLbyte * pc)
   1837 {
   1838     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1839     int error;
   1840     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1841 
   1842     pc += __GLX_SINGLE_HDR_SIZE;
   1843     if (cx != NULL) {
   1844         const GLenum pname = *(GLenum *) (pc + 4);
   1845 
   1846         const GLuint compsize = __glGetMaterialiv_size(pname);
   1847         GLint answerBuffer[200];
   1848         GLint *params =
   1849             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1850                                  sizeof(answerBuffer), 4);
   1851 
   1852         if (params == NULL)
   1853             return BadAlloc;
   1854         __glXClearErrorOccured();
   1855 
   1856         glGetMaterialiv(*(GLenum *) (pc + 0), pname, params);
   1857         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1858         error = Success;
   1859     }
   1860 
   1861     return error;
   1862 }
   1863 
   1864 int
   1865 __glXDisp_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc)
   1866 {
   1867     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1868     int error;
   1869     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1870 
   1871     pc += __GLX_SINGLE_HDR_SIZE;
   1872     if (cx != NULL) {
   1873         const GLenum map = *(GLenum *) (pc + 0);
   1874 
   1875         const GLuint compsize = __glGetPixelMapfv_size(map);
   1876         GLfloat answerBuffer[200];
   1877         GLfloat *values =
   1878             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1879                                  sizeof(answerBuffer), 4);
   1880 
   1881         if (values == NULL)
   1882             return BadAlloc;
   1883         __glXClearErrorOccured();
   1884 
   1885         glGetPixelMapfv(map, values);
   1886         __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
   1887         error = Success;
   1888     }
   1889 
   1890     return error;
   1891 }
   1892 
   1893 int
   1894 __glXDisp_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc)
   1895 {
   1896     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1897     int error;
   1898     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1899 
   1900     pc += __GLX_SINGLE_HDR_SIZE;
   1901     if (cx != NULL) {
   1902         const GLenum map = *(GLenum *) (pc + 0);
   1903 
   1904         const GLuint compsize = __glGetPixelMapuiv_size(map);
   1905         GLuint answerBuffer[200];
   1906         GLuint *values =
   1907             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1908                                  sizeof(answerBuffer), 4);
   1909 
   1910         if (values == NULL)
   1911             return BadAlloc;
   1912         __glXClearErrorOccured();
   1913 
   1914         glGetPixelMapuiv(map, values);
   1915         __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
   1916         error = Success;
   1917     }
   1918 
   1919     return error;
   1920 }
   1921 
   1922 int
   1923 __glXDisp_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc)
   1924 {
   1925     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1926     int error;
   1927     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1928 
   1929     pc += __GLX_SINGLE_HDR_SIZE;
   1930     if (cx != NULL) {
   1931         const GLenum map = *(GLenum *) (pc + 0);
   1932 
   1933         const GLuint compsize = __glGetPixelMapusv_size(map);
   1934         GLushort answerBuffer[200];
   1935         GLushort *values =
   1936             __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer,
   1937                                  sizeof(answerBuffer), 2);
   1938 
   1939         if (values == NULL)
   1940             return BadAlloc;
   1941         __glXClearErrorOccured();
   1942 
   1943         glGetPixelMapusv(map, values);
   1944         __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
   1945         error = Success;
   1946     }
   1947 
   1948     return error;
   1949 }
   1950 
   1951 int
   1952 __glXDisp_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc)
   1953 {
   1954     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1955     int error;
   1956     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1957 
   1958     pc += __GLX_SINGLE_HDR_SIZE;
   1959     if (cx != NULL) {
   1960         const GLenum pname = *(GLenum *) (pc + 4);
   1961 
   1962         const GLuint compsize = __glGetTexEnvfv_size(pname);
   1963         GLfloat answerBuffer[200];
   1964         GLfloat *params =
   1965             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1966                                  sizeof(answerBuffer), 4);
   1967 
   1968         if (params == NULL)
   1969             return BadAlloc;
   1970         __glXClearErrorOccured();
   1971 
   1972         glGetTexEnvfv(*(GLenum *) (pc + 0), pname, params);
   1973         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   1974         error = Success;
   1975     }
   1976 
   1977     return error;
   1978 }
   1979 
   1980 int
   1981 __glXDisp_GetTexEnviv(__GLXclientState * cl, GLbyte * pc)
   1982 {
   1983     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   1984     int error;
   1985     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   1986 
   1987     pc += __GLX_SINGLE_HDR_SIZE;
   1988     if (cx != NULL) {
   1989         const GLenum pname = *(GLenum *) (pc + 4);
   1990 
   1991         const GLuint compsize = __glGetTexEnviv_size(pname);
   1992         GLint answerBuffer[200];
   1993         GLint *params =
   1994             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   1995                                  sizeof(answerBuffer), 4);
   1996 
   1997         if (params == NULL)
   1998             return BadAlloc;
   1999         __glXClearErrorOccured();
   2000 
   2001         glGetTexEnviv(*(GLenum *) (pc + 0), pname, params);
   2002         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2003         error = Success;
   2004     }
   2005 
   2006     return error;
   2007 }
   2008 
   2009 int
   2010 __glXDisp_GetTexGendv(__GLXclientState * cl, GLbyte * pc)
   2011 {
   2012     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2013     int error;
   2014     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2015 
   2016     pc += __GLX_SINGLE_HDR_SIZE;
   2017     if (cx != NULL) {
   2018         const GLenum pname = *(GLenum *) (pc + 4);
   2019 
   2020         const GLuint compsize = __glGetTexGendv_size(pname);
   2021         GLdouble answerBuffer[200];
   2022         GLdouble *params =
   2023             __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
   2024                                  sizeof(answerBuffer), 8);
   2025 
   2026         if (params == NULL)
   2027             return BadAlloc;
   2028         __glXClearErrorOccured();
   2029 
   2030         glGetTexGendv(*(GLenum *) (pc + 0), pname, params);
   2031         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
   2032         error = Success;
   2033     }
   2034 
   2035     return error;
   2036 }
   2037 
   2038 int
   2039 __glXDisp_GetTexGenfv(__GLXclientState * cl, GLbyte * pc)
   2040 {
   2041     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2042     int error;
   2043     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2044 
   2045     pc += __GLX_SINGLE_HDR_SIZE;
   2046     if (cx != NULL) {
   2047         const GLenum pname = *(GLenum *) (pc + 4);
   2048 
   2049         const GLuint compsize = __glGetTexGenfv_size(pname);
   2050         GLfloat answerBuffer[200];
   2051         GLfloat *params =
   2052             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2053                                  sizeof(answerBuffer), 4);
   2054 
   2055         if (params == NULL)
   2056             return BadAlloc;
   2057         __glXClearErrorOccured();
   2058 
   2059         glGetTexGenfv(*(GLenum *) (pc + 0), pname, params);
   2060         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2061         error = Success;
   2062     }
   2063 
   2064     return error;
   2065 }
   2066 
   2067 int
   2068 __glXDisp_GetTexGeniv(__GLXclientState * cl, GLbyte * pc)
   2069 {
   2070     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2071     int error;
   2072     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2073 
   2074     pc += __GLX_SINGLE_HDR_SIZE;
   2075     if (cx != NULL) {
   2076         const GLenum pname = *(GLenum *) (pc + 4);
   2077 
   2078         const GLuint compsize = __glGetTexGeniv_size(pname);
   2079         GLint answerBuffer[200];
   2080         GLint *params =
   2081             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2082                                  sizeof(answerBuffer), 4);
   2083 
   2084         if (params == NULL)
   2085             return BadAlloc;
   2086         __glXClearErrorOccured();
   2087 
   2088         glGetTexGeniv(*(GLenum *) (pc + 0), pname, params);
   2089         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2090         error = Success;
   2091     }
   2092 
   2093     return error;
   2094 }
   2095 
   2096 int
   2097 __glXDisp_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc)
   2098 {
   2099     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2100     int error;
   2101     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2102 
   2103     pc += __GLX_SINGLE_HDR_SIZE;
   2104     if (cx != NULL) {
   2105         const GLenum pname = *(GLenum *) (pc + 4);
   2106 
   2107         const GLuint compsize = __glGetTexParameterfv_size(pname);
   2108         GLfloat answerBuffer[200];
   2109         GLfloat *params =
   2110             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2111                                  sizeof(answerBuffer), 4);
   2112 
   2113         if (params == NULL)
   2114             return BadAlloc;
   2115         __glXClearErrorOccured();
   2116 
   2117         glGetTexParameterfv(*(GLenum *) (pc + 0), pname, params);
   2118         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2119         error = Success;
   2120     }
   2121 
   2122     return error;
   2123 }
   2124 
   2125 int
   2126 __glXDisp_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc)
   2127 {
   2128     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2129     int error;
   2130     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2131 
   2132     pc += __GLX_SINGLE_HDR_SIZE;
   2133     if (cx != NULL) {
   2134         const GLenum pname = *(GLenum *) (pc + 4);
   2135 
   2136         const GLuint compsize = __glGetTexParameteriv_size(pname);
   2137         GLint answerBuffer[200];
   2138         GLint *params =
   2139             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2140                                  sizeof(answerBuffer), 4);
   2141 
   2142         if (params == NULL)
   2143             return BadAlloc;
   2144         __glXClearErrorOccured();
   2145 
   2146         glGetTexParameteriv(*(GLenum *) (pc + 0), pname, params);
   2147         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2148         error = Success;
   2149     }
   2150 
   2151     return error;
   2152 }
   2153 
   2154 int
   2155 __glXDisp_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc)
   2156 {
   2157     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2158     int error;
   2159     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2160 
   2161     pc += __GLX_SINGLE_HDR_SIZE;
   2162     if (cx != NULL) {
   2163         const GLenum pname = *(GLenum *) (pc + 8);
   2164 
   2165         const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
   2166         GLfloat answerBuffer[200];
   2167         GLfloat *params =
   2168             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2169                                  sizeof(answerBuffer), 4);
   2170 
   2171         if (params == NULL)
   2172             return BadAlloc;
   2173         __glXClearErrorOccured();
   2174 
   2175         glGetTexLevelParameterfv(*(GLenum *) (pc + 0),
   2176                                  *(GLint *) (pc + 4), pname, params);
   2177         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2178         error = Success;
   2179     }
   2180 
   2181     return error;
   2182 }
   2183 
   2184 int
   2185 __glXDisp_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc)
   2186 {
   2187     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2188     int error;
   2189     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2190 
   2191     pc += __GLX_SINGLE_HDR_SIZE;
   2192     if (cx != NULL) {
   2193         const GLenum pname = *(GLenum *) (pc + 8);
   2194 
   2195         const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
   2196         GLint answerBuffer[200];
   2197         GLint *params =
   2198             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2199                                  sizeof(answerBuffer), 4);
   2200 
   2201         if (params == NULL)
   2202             return BadAlloc;
   2203         __glXClearErrorOccured();
   2204 
   2205         glGetTexLevelParameteriv(*(GLenum *) (pc + 0),
   2206                                  *(GLint *) (pc + 4), pname, params);
   2207         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2208         error = Success;
   2209     }
   2210 
   2211     return error;
   2212 }
   2213 
   2214 int
   2215 __glXDisp_IsEnabled(__GLXclientState * cl, GLbyte * pc)
   2216 {
   2217     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2218     int error;
   2219     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2220 
   2221     pc += __GLX_SINGLE_HDR_SIZE;
   2222     if (cx != NULL) {
   2223         GLboolean retval;
   2224 
   2225         retval = glIsEnabled(*(GLenum *) (pc + 0));
   2226         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   2227         error = Success;
   2228     }
   2229 
   2230     return error;
   2231 }
   2232 
   2233 int
   2234 __glXDisp_IsList(__GLXclientState * cl, GLbyte * pc)
   2235 {
   2236     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2237     int error;
   2238     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2239 
   2240     pc += __GLX_SINGLE_HDR_SIZE;
   2241     if (cx != NULL) {
   2242         GLboolean retval;
   2243 
   2244         retval = glIsList(*(GLuint *) (pc + 0));
   2245         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   2246         error = Success;
   2247     }
   2248 
   2249     return error;
   2250 }
   2251 
   2252 void
   2253 __glXDisp_DepthRange(GLbyte * pc)
   2254 {
   2255 #ifdef __GLX_ALIGN64
   2256     if ((unsigned long) (pc) & 7) {
   2257         (void) memmove(pc - 4, pc, 16);
   2258         pc -= 4;
   2259     }
   2260 #endif
   2261 
   2262     glDepthRange(*(GLclampd *) (pc + 0), *(GLclampd *) (pc + 8));
   2263 }
   2264 
   2265 void
   2266 __glXDisp_Frustum(GLbyte * pc)
   2267 {
   2268 #ifdef __GLX_ALIGN64
   2269     if ((unsigned long) (pc) & 7) {
   2270         (void) memmove(pc - 4, pc, 48);
   2271         pc -= 4;
   2272     }
   2273 #endif
   2274 
   2275     glFrustum(*(GLdouble *) (pc + 0),
   2276               *(GLdouble *) (pc + 8),
   2277               *(GLdouble *) (pc + 16),
   2278               *(GLdouble *) (pc + 24),
   2279               *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40));
   2280 }
   2281 
   2282 void
   2283 __glXDisp_LoadIdentity(GLbyte * pc)
   2284 {
   2285     glLoadIdentity();
   2286 }
   2287 
   2288 void
   2289 __glXDisp_LoadMatrixf(GLbyte * pc)
   2290 {
   2291     glLoadMatrixf((const GLfloat *) (pc + 0));
   2292 }
   2293 
   2294 void
   2295 __glXDisp_LoadMatrixd(GLbyte * pc)
   2296 {
   2297 #ifdef __GLX_ALIGN64
   2298     if ((unsigned long) (pc) & 7) {
   2299         (void) memmove(pc - 4, pc, 128);
   2300         pc -= 4;
   2301     }
   2302 #endif
   2303 
   2304     glLoadMatrixd((const GLdouble *) (pc + 0));
   2305 }
   2306 
   2307 void
   2308 __glXDisp_MatrixMode(GLbyte * pc)
   2309 {
   2310     glMatrixMode(*(GLenum *) (pc + 0));
   2311 }
   2312 
   2313 void
   2314 __glXDisp_MultMatrixf(GLbyte * pc)
   2315 {
   2316     glMultMatrixf((const GLfloat *) (pc + 0));
   2317 }
   2318 
   2319 void
   2320 __glXDisp_MultMatrixd(GLbyte * pc)
   2321 {
   2322 #ifdef __GLX_ALIGN64
   2323     if ((unsigned long) (pc) & 7) {
   2324         (void) memmove(pc - 4, pc, 128);
   2325         pc -= 4;
   2326     }
   2327 #endif
   2328 
   2329     glMultMatrixd((const GLdouble *) (pc + 0));
   2330 }
   2331 
   2332 void
   2333 __glXDisp_Ortho(GLbyte * pc)
   2334 {
   2335 #ifdef __GLX_ALIGN64
   2336     if ((unsigned long) (pc) & 7) {
   2337         (void) memmove(pc - 4, pc, 48);
   2338         pc -= 4;
   2339     }
   2340 #endif
   2341 
   2342     glOrtho(*(GLdouble *) (pc + 0),
   2343             *(GLdouble *) (pc + 8),
   2344             *(GLdouble *) (pc + 16),
   2345             *(GLdouble *) (pc + 24),
   2346             *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40));
   2347 }
   2348 
   2349 void
   2350 __glXDisp_PopMatrix(GLbyte * pc)
   2351 {
   2352     glPopMatrix();
   2353 }
   2354 
   2355 void
   2356 __glXDisp_PushMatrix(GLbyte * pc)
   2357 {
   2358     glPushMatrix();
   2359 }
   2360 
   2361 void
   2362 __glXDisp_Rotated(GLbyte * pc)
   2363 {
   2364 #ifdef __GLX_ALIGN64
   2365     if ((unsigned long) (pc) & 7) {
   2366         (void) memmove(pc - 4, pc, 32);
   2367         pc -= 4;
   2368     }
   2369 #endif
   2370 
   2371     glRotated(*(GLdouble *) (pc + 0),
   2372               *(GLdouble *) (pc + 8),
   2373               *(GLdouble *) (pc + 16), *(GLdouble *) (pc + 24));
   2374 }
   2375 
   2376 void
   2377 __glXDisp_Rotatef(GLbyte * pc)
   2378 {
   2379     glRotatef(*(GLfloat *) (pc + 0),
   2380               *(GLfloat *) (pc + 4),
   2381               *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12));
   2382 }
   2383 
   2384 void
   2385 __glXDisp_Scaled(GLbyte * pc)
   2386 {
   2387 #ifdef __GLX_ALIGN64
   2388     if ((unsigned long) (pc) & 7) {
   2389         (void) memmove(pc - 4, pc, 24);
   2390         pc -= 4;
   2391     }
   2392 #endif
   2393 
   2394     glScaled(*(GLdouble *) (pc + 0),
   2395              *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16));
   2396 }
   2397 
   2398 void
   2399 __glXDisp_Scalef(GLbyte * pc)
   2400 {
   2401     glScalef(*(GLfloat *) (pc + 0),
   2402              *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8));
   2403 }
   2404 
   2405 void
   2406 __glXDisp_Translated(GLbyte * pc)
   2407 {
   2408 #ifdef __GLX_ALIGN64
   2409     if ((unsigned long) (pc) & 7) {
   2410         (void) memmove(pc - 4, pc, 24);
   2411         pc -= 4;
   2412     }
   2413 #endif
   2414 
   2415     glTranslated(*(GLdouble *) (pc + 0),
   2416                  *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16));
   2417 }
   2418 
   2419 void
   2420 __glXDisp_Translatef(GLbyte * pc)
   2421 {
   2422     glTranslatef(*(GLfloat *) (pc + 0),
   2423                  *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8));
   2424 }
   2425 
   2426 void
   2427 __glXDisp_Viewport(GLbyte * pc)
   2428 {
   2429     glViewport(*(GLint *) (pc + 0),
   2430                *(GLint *) (pc + 4),
   2431                *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
   2432 }
   2433 
   2434 void
   2435 __glXDisp_BindTexture(GLbyte * pc)
   2436 {
   2437     glBindTexture(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
   2438 }
   2439 
   2440 void
   2441 __glXDisp_Indexubv(GLbyte * pc)
   2442 {
   2443     glIndexubv((const GLubyte *) (pc + 0));
   2444 }
   2445 
   2446 void
   2447 __glXDisp_PolygonOffset(GLbyte * pc)
   2448 {
   2449     glPolygonOffset(*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4));
   2450 }
   2451 
   2452 int
   2453 __glXDisp_AreTexturesResident(__GLXclientState * cl, GLbyte * pc)
   2454 {
   2455     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2456     int error;
   2457     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2458 
   2459     pc += __GLX_SINGLE_HDR_SIZE;
   2460     if (cx != NULL) {
   2461         const GLsizei n = *(GLsizei *) (pc + 0);
   2462 
   2463         GLboolean retval;
   2464         GLboolean answerBuffer[200];
   2465         GLboolean *residences =
   2466             __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
   2467 
   2468         if (residences == NULL)
   2469             return BadAlloc;
   2470         retval =
   2471             glAreTexturesResident(n, (const GLuint *) (pc + 4), residences);
   2472         __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
   2473         error = Success;
   2474     }
   2475 
   2476     return error;
   2477 }
   2478 
   2479 int
   2480 __glXDisp_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc)
   2481 {
   2482     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   2483     int error;
   2484     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2485 
   2486     pc += __GLX_VENDPRIV_HDR_SIZE;
   2487     if (cx != NULL) {
   2488         const GLsizei n = *(GLsizei *) (pc + 0);
   2489 
   2490         GLboolean retval;
   2491         GLboolean answerBuffer[200];
   2492         GLboolean *residences =
   2493             __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
   2494 
   2495         if (residences == NULL)
   2496             return BadAlloc;
   2497         retval =
   2498             glAreTexturesResident(n, (const GLuint *) (pc + 4), residences);
   2499         __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
   2500         error = Success;
   2501     }
   2502 
   2503     return error;
   2504 }
   2505 
   2506 void
   2507 __glXDisp_CopyTexImage1D(GLbyte * pc)
   2508 {
   2509     glCopyTexImage1D(*(GLenum *) (pc + 0),
   2510                      *(GLint *) (pc + 4),
   2511                      *(GLenum *) (pc + 8),
   2512                      *(GLint *) (pc + 12),
   2513                      *(GLint *) (pc + 16),
   2514                      *(GLsizei *) (pc + 20), *(GLint *) (pc + 24));
   2515 }
   2516 
   2517 void
   2518 __glXDisp_CopyTexImage2D(GLbyte * pc)
   2519 {
   2520     glCopyTexImage2D(*(GLenum *) (pc + 0),
   2521                      *(GLint *) (pc + 4),
   2522                      *(GLenum *) (pc + 8),
   2523                      *(GLint *) (pc + 12),
   2524                      *(GLint *) (pc + 16),
   2525                      *(GLsizei *) (pc + 20),
   2526                      *(GLsizei *) (pc + 24), *(GLint *) (pc + 28));
   2527 }
   2528 
   2529 void
   2530 __glXDisp_CopyTexSubImage1D(GLbyte * pc)
   2531 {
   2532     glCopyTexSubImage1D(*(GLenum *) (pc + 0),
   2533                         *(GLint *) (pc + 4),
   2534                         *(GLint *) (pc + 8),
   2535                         *(GLint *) (pc + 12),
   2536                         *(GLint *) (pc + 16), *(GLsizei *) (pc + 20));
   2537 }
   2538 
   2539 void
   2540 __glXDisp_CopyTexSubImage2D(GLbyte * pc)
   2541 {
   2542     glCopyTexSubImage2D(*(GLenum *) (pc + 0),
   2543                         *(GLint *) (pc + 4),
   2544                         *(GLint *) (pc + 8),
   2545                         *(GLint *) (pc + 12),
   2546                         *(GLint *) (pc + 16),
   2547                         *(GLint *) (pc + 20),
   2548                         *(GLsizei *) (pc + 24), *(GLsizei *) (pc + 28));
   2549 }
   2550 
   2551 int
   2552 __glXDisp_DeleteTextures(__GLXclientState * cl, GLbyte * pc)
   2553 {
   2554     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2555     int error;
   2556     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2557 
   2558     pc += __GLX_SINGLE_HDR_SIZE;
   2559     if (cx != NULL) {
   2560         const GLsizei n = *(GLsizei *) (pc + 0);
   2561 
   2562         glDeleteTextures(n, (const GLuint *) (pc + 4));
   2563         error = Success;
   2564     }
   2565 
   2566     return error;
   2567 }
   2568 
   2569 int
   2570 __glXDisp_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc)
   2571 {
   2572     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   2573     int error;
   2574     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2575 
   2576     pc += __GLX_VENDPRIV_HDR_SIZE;
   2577     if (cx != NULL) {
   2578         const GLsizei n = *(GLsizei *) (pc + 0);
   2579 
   2580         glDeleteTextures(n, (const GLuint *) (pc + 4));
   2581         error = Success;
   2582     }
   2583 
   2584     return error;
   2585 }
   2586 
   2587 int
   2588 __glXDisp_GenTextures(__GLXclientState * cl, GLbyte * pc)
   2589 {
   2590     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2591     int error;
   2592     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2593 
   2594     pc += __GLX_SINGLE_HDR_SIZE;
   2595     if (cx != NULL) {
   2596         const GLsizei n = *(GLsizei *) (pc + 0);
   2597 
   2598         GLuint answerBuffer[200];
   2599         GLuint *textures =
   2600             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
   2601                                  4);
   2602 
   2603         if (textures == NULL)
   2604             return BadAlloc;
   2605         glGenTextures(n, textures);
   2606         __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
   2607         error = Success;
   2608     }
   2609 
   2610     return error;
   2611 }
   2612 
   2613 int
   2614 __glXDisp_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc)
   2615 {
   2616     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   2617     int error;
   2618     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2619 
   2620     pc += __GLX_VENDPRIV_HDR_SIZE;
   2621     if (cx != NULL) {
   2622         const GLsizei n = *(GLsizei *) (pc + 0);
   2623 
   2624         GLuint answerBuffer[200];
   2625         GLuint *textures =
   2626             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
   2627                                  4);
   2628 
   2629         if (textures == NULL)
   2630             return BadAlloc;
   2631         glGenTextures(n, textures);
   2632         __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
   2633         error = Success;
   2634     }
   2635 
   2636     return error;
   2637 }
   2638 
   2639 int
   2640 __glXDisp_IsTexture(__GLXclientState * cl, GLbyte * pc)
   2641 {
   2642     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2643     int error;
   2644     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2645 
   2646     pc += __GLX_SINGLE_HDR_SIZE;
   2647     if (cx != NULL) {
   2648         GLboolean retval;
   2649 
   2650         retval = glIsTexture(*(GLuint *) (pc + 0));
   2651         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   2652         error = Success;
   2653     }
   2654 
   2655     return error;
   2656 }
   2657 
   2658 int
   2659 __glXDisp_IsTextureEXT(__GLXclientState * cl, GLbyte * pc)
   2660 {
   2661     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   2662     int error;
   2663     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2664 
   2665     pc += __GLX_VENDPRIV_HDR_SIZE;
   2666     if (cx != NULL) {
   2667         GLboolean retval;
   2668 
   2669         retval = glIsTexture(*(GLuint *) (pc + 0));
   2670         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   2671         error = Success;
   2672     }
   2673 
   2674     return error;
   2675 }
   2676 
   2677 void
   2678 __glXDisp_PrioritizeTextures(GLbyte * pc)
   2679 {
   2680     const GLsizei n = *(GLsizei *) (pc + 0);
   2681 
   2682     glPrioritizeTextures(n,
   2683                          (const GLuint *) (pc + 4),
   2684                          (const GLclampf *) (pc + 4));
   2685 }
   2686 
   2687 void
   2688 __glXDisp_TexSubImage1D(GLbyte * pc)
   2689 {
   2690     const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
   2691     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   2692 
   2693     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   2694     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   2695     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   2696     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   2697     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   2698     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   2699 
   2700     glTexSubImage1D(*(GLenum *) (pc + 20),
   2701                     *(GLint *) (pc + 24),
   2702                     *(GLint *) (pc + 28),
   2703                     *(GLsizei *) (pc + 36),
   2704                     *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
   2705 }
   2706 
   2707 void
   2708 __glXDisp_TexSubImage2D(GLbyte * pc)
   2709 {
   2710     const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
   2711     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   2712 
   2713     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   2714     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   2715     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   2716     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   2717     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   2718     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   2719 
   2720     glTexSubImage2D(*(GLenum *) (pc + 20),
   2721                     *(GLint *) (pc + 24),
   2722                     *(GLint *) (pc + 28),
   2723                     *(GLint *) (pc + 32),
   2724                     *(GLsizei *) (pc + 36),
   2725                     *(GLsizei *) (pc + 40),
   2726                     *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
   2727 }
   2728 
   2729 void
   2730 __glXDisp_BlendColor(GLbyte * pc)
   2731 {
   2732     glBlendColor(*(GLclampf *) (pc + 0),
   2733                  *(GLclampf *) (pc + 4),
   2734                  *(GLclampf *) (pc + 8), *(GLclampf *) (pc + 12));
   2735 }
   2736 
   2737 void
   2738 __glXDisp_BlendEquation(GLbyte * pc)
   2739 {
   2740     glBlendEquation(*(GLenum *) (pc + 0));
   2741 }
   2742 
   2743 void
   2744 __glXDisp_ColorTable(GLbyte * pc)
   2745 {
   2746     const GLvoid *const table = (const GLvoid *) ((pc + 40));
   2747     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   2748 
   2749     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   2750     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   2751     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   2752     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   2753     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   2754     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   2755 
   2756     glColorTable(*(GLenum *) (pc + 20),
   2757                  *(GLenum *) (pc + 24),
   2758                  *(GLsizei *) (pc + 28),
   2759                  *(GLenum *) (pc + 32), *(GLenum *) (pc + 36), table);
   2760 }
   2761 
   2762 void
   2763 __glXDisp_ColorTableParameterfv(GLbyte * pc)
   2764 {
   2765     const GLenum pname = *(GLenum *) (pc + 4);
   2766     const GLfloat *params;
   2767 
   2768     params = (const GLfloat *) (pc + 8);
   2769 
   2770     glColorTableParameterfv(*(GLenum *) (pc + 0), pname, params);
   2771 }
   2772 
   2773 void
   2774 __glXDisp_ColorTableParameteriv(GLbyte * pc)
   2775 {
   2776     const GLenum pname = *(GLenum *) (pc + 4);
   2777     const GLint *params;
   2778 
   2779     params = (const GLint *) (pc + 8);
   2780 
   2781     glColorTableParameteriv(*(GLenum *) (pc + 0), pname, params);
   2782 }
   2783 
   2784 void
   2785 __glXDisp_CopyColorTable(GLbyte * pc)
   2786 {
   2787     glCopyColorTable(*(GLenum *) (pc + 0),
   2788                      *(GLenum *) (pc + 4),
   2789                      *(GLint *) (pc + 8),
   2790                      *(GLint *) (pc + 12), *(GLsizei *) (pc + 16));
   2791 }
   2792 
   2793 int
   2794 __glXDisp_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc)
   2795 {
   2796     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2797     int error;
   2798     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2799 
   2800     pc += __GLX_SINGLE_HDR_SIZE;
   2801     if (cx != NULL) {
   2802         const GLenum pname = *(GLenum *) (pc + 4);
   2803 
   2804         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
   2805         GLfloat answerBuffer[200];
   2806         GLfloat *params =
   2807             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2808                                  sizeof(answerBuffer), 4);
   2809 
   2810         if (params == NULL)
   2811             return BadAlloc;
   2812         __glXClearErrorOccured();
   2813 
   2814         glGetColorTableParameterfv(*(GLenum *) (pc + 0), pname, params);
   2815         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2816         error = Success;
   2817     }
   2818 
   2819     return error;
   2820 }
   2821 
   2822 int
   2823 __glXDisp_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc)
   2824 {
   2825     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   2826     int error;
   2827     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2828 
   2829     pc += __GLX_VENDPRIV_HDR_SIZE;
   2830     if (cx != NULL) {
   2831         const GLenum pname = *(GLenum *) (pc + 4);
   2832 
   2833         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
   2834         GLfloat answerBuffer[200];
   2835         GLfloat *params =
   2836             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2837                                  sizeof(answerBuffer), 4);
   2838 
   2839         if (params == NULL)
   2840             return BadAlloc;
   2841         __glXClearErrorOccured();
   2842 
   2843         glGetColorTableParameterfv(*(GLenum *) (pc + 0), pname, params);
   2844         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2845         error = Success;
   2846     }
   2847 
   2848     return error;
   2849 }
   2850 
   2851 int
   2852 __glXDisp_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc)
   2853 {
   2854     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   2855     int error;
   2856     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2857 
   2858     pc += __GLX_SINGLE_HDR_SIZE;
   2859     if (cx != NULL) {
   2860         const GLenum pname = *(GLenum *) (pc + 4);
   2861 
   2862         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
   2863         GLint answerBuffer[200];
   2864         GLint *params =
   2865             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2866                                  sizeof(answerBuffer), 4);
   2867 
   2868         if (params == NULL)
   2869             return BadAlloc;
   2870         __glXClearErrorOccured();
   2871 
   2872         glGetColorTableParameteriv(*(GLenum *) (pc + 0), pname, params);
   2873         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2874         error = Success;
   2875     }
   2876 
   2877     return error;
   2878 }
   2879 
   2880 int
   2881 __glXDisp_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc)
   2882 {
   2883     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   2884     int error;
   2885     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   2886 
   2887     pc += __GLX_VENDPRIV_HDR_SIZE;
   2888     if (cx != NULL) {
   2889         const GLenum pname = *(GLenum *) (pc + 4);
   2890 
   2891         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
   2892         GLint answerBuffer[200];
   2893         GLint *params =
   2894             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   2895                                  sizeof(answerBuffer), 4);
   2896 
   2897         if (params == NULL)
   2898             return BadAlloc;
   2899         __glXClearErrorOccured();
   2900 
   2901         glGetColorTableParameteriv(*(GLenum *) (pc + 0), pname, params);
   2902         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   2903         error = Success;
   2904     }
   2905 
   2906     return error;
   2907 }
   2908 
   2909 void
   2910 __glXDisp_ColorSubTable(GLbyte * pc)
   2911 {
   2912     const GLvoid *const data = (const GLvoid *) ((pc + 40));
   2913     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   2914 
   2915     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   2916     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   2917     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   2918     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   2919     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   2920     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   2921 
   2922     glColorSubTable(*(GLenum *) (pc + 20),
   2923                     *(GLsizei *) (pc + 24),
   2924                     *(GLsizei *) (pc + 28),
   2925                     *(GLenum *) (pc + 32), *(GLenum *) (pc + 36), data);
   2926 }
   2927 
   2928 void
   2929 __glXDisp_CopyColorSubTable(GLbyte * pc)
   2930 {
   2931     glCopyColorSubTable(*(GLenum *) (pc + 0),
   2932                         *(GLsizei *) (pc + 4),
   2933                         *(GLint *) (pc + 8),
   2934                         *(GLint *) (pc + 12), *(GLsizei *) (pc + 16));
   2935 }
   2936 
   2937 void
   2938 __glXDisp_ConvolutionFilter1D(GLbyte * pc)
   2939 {
   2940     const GLvoid *const image = (const GLvoid *) ((pc + 44));
   2941     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   2942 
   2943     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   2944     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   2945     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   2946     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   2947     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   2948     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   2949 
   2950     glConvolutionFilter1D(*(GLenum *) (pc + 20),
   2951                           *(GLenum *) (pc + 24),
   2952                           *(GLsizei *) (pc + 28),
   2953                           *(GLenum *) (pc + 36), *(GLenum *) (pc + 40), image);
   2954 }
   2955 
   2956 void
   2957 __glXDisp_ConvolutionFilter2D(GLbyte * pc)
   2958 {
   2959     const GLvoid *const image = (const GLvoid *) ((pc + 44));
   2960     __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
   2961 
   2962     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   2963     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   2964     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   2965     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   2966     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   2967     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   2968 
   2969     glConvolutionFilter2D(*(GLenum *) (pc + 20),
   2970                           *(GLenum *) (pc + 24),
   2971                           *(GLsizei *) (pc + 28),
   2972                           *(GLsizei *) (pc + 32),
   2973                           *(GLenum *) (pc + 36), *(GLenum *) (pc + 40), image);
   2974 }
   2975 
   2976 void
   2977 __glXDisp_ConvolutionParameterf(GLbyte * pc)
   2978 {
   2979     glConvolutionParameterf(*(GLenum *) (pc + 0),
   2980                             *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
   2981 }
   2982 
   2983 void
   2984 __glXDisp_ConvolutionParameterfv(GLbyte * pc)
   2985 {
   2986     const GLenum pname = *(GLenum *) (pc + 4);
   2987     const GLfloat *params;
   2988 
   2989     params = (const GLfloat *) (pc + 8);
   2990 
   2991     glConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params);
   2992 }
   2993 
   2994 void
   2995 __glXDisp_ConvolutionParameteri(GLbyte * pc)
   2996 {
   2997     glConvolutionParameteri(*(GLenum *) (pc + 0),
   2998                             *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
   2999 }
   3000 
   3001 void
   3002 __glXDisp_ConvolutionParameteriv(GLbyte * pc)
   3003 {
   3004     const GLenum pname = *(GLenum *) (pc + 4);
   3005     const GLint *params;
   3006 
   3007     params = (const GLint *) (pc + 8);
   3008 
   3009     glConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params);
   3010 }
   3011 
   3012 void
   3013 __glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
   3014 {
   3015     glCopyConvolutionFilter1D(*(GLenum *) (pc + 0),
   3016                               *(GLenum *) (pc + 4),
   3017                               *(GLint *) (pc + 8),
   3018                               *(GLint *) (pc + 12), *(GLsizei *) (pc + 16));
   3019 }
   3020 
   3021 void
   3022 __glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
   3023 {
   3024     glCopyConvolutionFilter2D(*(GLenum *) (pc + 0),
   3025                               *(GLenum *) (pc + 4),
   3026                               *(GLint *) (pc + 8),
   3027                               *(GLint *) (pc + 12),
   3028                               *(GLsizei *) (pc + 16), *(GLsizei *) (pc + 20));
   3029 }
   3030 
   3031 int
   3032 __glXDisp_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc)
   3033 {
   3034     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3035     int error;
   3036     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3037 
   3038     pc += __GLX_SINGLE_HDR_SIZE;
   3039     if (cx != NULL) {
   3040         const GLenum pname = *(GLenum *) (pc + 4);
   3041 
   3042         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
   3043         GLfloat answerBuffer[200];
   3044         GLfloat *params =
   3045             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3046                                  sizeof(answerBuffer), 4);
   3047 
   3048         if (params == NULL)
   3049             return BadAlloc;
   3050         __glXClearErrorOccured();
   3051 
   3052         glGetConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params);
   3053         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3054         error = Success;
   3055     }
   3056 
   3057     return error;
   3058 }
   3059 
   3060 int
   3061 __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
   3062 {
   3063     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   3064     int error;
   3065     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3066 
   3067     pc += __GLX_VENDPRIV_HDR_SIZE;
   3068     if (cx != NULL) {
   3069         const GLenum pname = *(GLenum *) (pc + 4);
   3070 
   3071         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
   3072         GLfloat answerBuffer[200];
   3073         GLfloat *params =
   3074             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3075                                  sizeof(answerBuffer), 4);
   3076 
   3077         if (params == NULL)
   3078             return BadAlloc;
   3079         __glXClearErrorOccured();
   3080 
   3081         glGetConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params);
   3082         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3083         error = Success;
   3084     }
   3085 
   3086     return error;
   3087 }
   3088 
   3089 int
   3090 __glXDisp_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc)
   3091 {
   3092     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3093     int error;
   3094     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3095 
   3096     pc += __GLX_SINGLE_HDR_SIZE;
   3097     if (cx != NULL) {
   3098         const GLenum pname = *(GLenum *) (pc + 4);
   3099 
   3100         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
   3101         GLint answerBuffer[200];
   3102         GLint *params =
   3103             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3104                                  sizeof(answerBuffer), 4);
   3105 
   3106         if (params == NULL)
   3107             return BadAlloc;
   3108         __glXClearErrorOccured();
   3109 
   3110         glGetConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params);
   3111         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3112         error = Success;
   3113     }
   3114 
   3115     return error;
   3116 }
   3117 
   3118 int
   3119 __glXDisp_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc)
   3120 {
   3121     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   3122     int error;
   3123     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3124 
   3125     pc += __GLX_VENDPRIV_HDR_SIZE;
   3126     if (cx != NULL) {
   3127         const GLenum pname = *(GLenum *) (pc + 4);
   3128 
   3129         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
   3130         GLint answerBuffer[200];
   3131         GLint *params =
   3132             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3133                                  sizeof(answerBuffer), 4);
   3134 
   3135         if (params == NULL)
   3136             return BadAlloc;
   3137         __glXClearErrorOccured();
   3138 
   3139         glGetConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params);
   3140         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3141         error = Success;
   3142     }
   3143 
   3144     return error;
   3145 }
   3146 
   3147 int
   3148 __glXDisp_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc)
   3149 {
   3150     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3151     int error;
   3152     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3153 
   3154     pc += __GLX_SINGLE_HDR_SIZE;
   3155     if (cx != NULL) {
   3156         const GLenum pname = *(GLenum *) (pc + 4);
   3157 
   3158         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
   3159         GLfloat answerBuffer[200];
   3160         GLfloat *params =
   3161             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3162                                  sizeof(answerBuffer), 4);
   3163 
   3164         if (params == NULL)
   3165             return BadAlloc;
   3166         __glXClearErrorOccured();
   3167 
   3168         glGetHistogramParameterfv(*(GLenum *) (pc + 0), pname, params);
   3169         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3170         error = Success;
   3171     }
   3172 
   3173     return error;
   3174 }
   3175 
   3176 int
   3177 __glXDisp_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
   3178 {
   3179     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   3180     int error;
   3181     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3182 
   3183     pc += __GLX_VENDPRIV_HDR_SIZE;
   3184     if (cx != NULL) {
   3185         const GLenum pname = *(GLenum *) (pc + 4);
   3186 
   3187         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
   3188         GLfloat answerBuffer[200];
   3189         GLfloat *params =
   3190             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3191                                  sizeof(answerBuffer), 4);
   3192 
   3193         if (params == NULL)
   3194             return BadAlloc;
   3195         __glXClearErrorOccured();
   3196 
   3197         glGetHistogramParameterfv(*(GLenum *) (pc + 0), pname, params);
   3198         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3199         error = Success;
   3200     }
   3201 
   3202     return error;
   3203 }
   3204 
   3205 int
   3206 __glXDisp_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc)
   3207 {
   3208     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3209     int error;
   3210     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3211 
   3212     pc += __GLX_SINGLE_HDR_SIZE;
   3213     if (cx != NULL) {
   3214         const GLenum pname = *(GLenum *) (pc + 4);
   3215 
   3216         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
   3217         GLint answerBuffer[200];
   3218         GLint *params =
   3219             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3220                                  sizeof(answerBuffer), 4);
   3221 
   3222         if (params == NULL)
   3223             return BadAlloc;
   3224         __glXClearErrorOccured();
   3225 
   3226         glGetHistogramParameteriv(*(GLenum *) (pc + 0), pname, params);
   3227         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3228         error = Success;
   3229     }
   3230 
   3231     return error;
   3232 }
   3233 
   3234 int
   3235 __glXDisp_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc)
   3236 {
   3237     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   3238     int error;
   3239     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3240 
   3241     pc += __GLX_VENDPRIV_HDR_SIZE;
   3242     if (cx != NULL) {
   3243         const GLenum pname = *(GLenum *) (pc + 4);
   3244 
   3245         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
   3246         GLint answerBuffer[200];
   3247         GLint *params =
   3248             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3249                                  sizeof(answerBuffer), 4);
   3250 
   3251         if (params == NULL)
   3252             return BadAlloc;
   3253         __glXClearErrorOccured();
   3254 
   3255         glGetHistogramParameteriv(*(GLenum *) (pc + 0), pname, params);
   3256         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3257         error = Success;
   3258     }
   3259 
   3260     return error;
   3261 }
   3262 
   3263 int
   3264 __glXDisp_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc)
   3265 {
   3266     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3267     int error;
   3268     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3269 
   3270     pc += __GLX_SINGLE_HDR_SIZE;
   3271     if (cx != NULL) {
   3272         const GLenum pname = *(GLenum *) (pc + 4);
   3273 
   3274         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
   3275         GLfloat answerBuffer[200];
   3276         GLfloat *params =
   3277             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3278                                  sizeof(answerBuffer), 4);
   3279 
   3280         if (params == NULL)
   3281             return BadAlloc;
   3282         __glXClearErrorOccured();
   3283 
   3284         glGetMinmaxParameterfv(*(GLenum *) (pc + 0), pname, params);
   3285         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3286         error = Success;
   3287     }
   3288 
   3289     return error;
   3290 }
   3291 
   3292 int
   3293 __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
   3294 {
   3295     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   3296     int error;
   3297     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3298 
   3299     pc += __GLX_VENDPRIV_HDR_SIZE;
   3300     if (cx != NULL) {
   3301         const GLenum pname = *(GLenum *) (pc + 4);
   3302 
   3303         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
   3304         GLfloat answerBuffer[200];
   3305         GLfloat *params =
   3306             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3307                                  sizeof(answerBuffer), 4);
   3308 
   3309         if (params == NULL)
   3310             return BadAlloc;
   3311         __glXClearErrorOccured();
   3312 
   3313         glGetMinmaxParameterfv(*(GLenum *) (pc + 0), pname, params);
   3314         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3315         error = Success;
   3316     }
   3317 
   3318     return error;
   3319 }
   3320 
   3321 int
   3322 __glXDisp_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc)
   3323 {
   3324     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3325     int error;
   3326     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3327 
   3328     pc += __GLX_SINGLE_HDR_SIZE;
   3329     if (cx != NULL) {
   3330         const GLenum pname = *(GLenum *) (pc + 4);
   3331 
   3332         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
   3333         GLint answerBuffer[200];
   3334         GLint *params =
   3335             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3336                                  sizeof(answerBuffer), 4);
   3337 
   3338         if (params == NULL)
   3339             return BadAlloc;
   3340         __glXClearErrorOccured();
   3341 
   3342         glGetMinmaxParameteriv(*(GLenum *) (pc + 0), pname, params);
   3343         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3344         error = Success;
   3345     }
   3346 
   3347     return error;
   3348 }
   3349 
   3350 int
   3351 __glXDisp_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc)
   3352 {
   3353     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   3354     int error;
   3355     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3356 
   3357     pc += __GLX_VENDPRIV_HDR_SIZE;
   3358     if (cx != NULL) {
   3359         const GLenum pname = *(GLenum *) (pc + 4);
   3360 
   3361         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
   3362         GLint answerBuffer[200];
   3363         GLint *params =
   3364             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3365                                  sizeof(answerBuffer), 4);
   3366 
   3367         if (params == NULL)
   3368             return BadAlloc;
   3369         __glXClearErrorOccured();
   3370 
   3371         glGetMinmaxParameteriv(*(GLenum *) (pc + 0), pname, params);
   3372         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3373         error = Success;
   3374     }
   3375 
   3376     return error;
   3377 }
   3378 
   3379 void
   3380 __glXDisp_Histogram(GLbyte * pc)
   3381 {
   3382     glHistogram(*(GLenum *) (pc + 0),
   3383                 *(GLsizei *) (pc + 4),
   3384                 *(GLenum *) (pc + 8), *(GLboolean *) (pc + 12));
   3385 }
   3386 
   3387 void
   3388 __glXDisp_Minmax(GLbyte * pc)
   3389 {
   3390     glMinmax(*(GLenum *) (pc + 0),
   3391              *(GLenum *) (pc + 4), *(GLboolean *) (pc + 8));
   3392 }
   3393 
   3394 void
   3395 __glXDisp_ResetHistogram(GLbyte * pc)
   3396 {
   3397     glResetHistogram(*(GLenum *) (pc + 0));
   3398 }
   3399 
   3400 void
   3401 __glXDisp_ResetMinmax(GLbyte * pc)
   3402 {
   3403     glResetMinmax(*(GLenum *) (pc + 0));
   3404 }
   3405 
   3406 void
   3407 __glXDisp_TexImage3D(GLbyte * pc)
   3408 {
   3409     const CARD32 ptr_is_null = *(CARD32 *) (pc + 76);
   3410     const GLvoid *const pixels =
   3411         (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
   3412     __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
   3413 
   3414     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   3415     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   3416     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   3417     glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight);
   3418     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   3419     glPixelStorei(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages);
   3420     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   3421     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   3422 
   3423     glTexImage3D(*(GLenum *) (pc + 36),
   3424                  *(GLint *) (pc + 40),
   3425                  *(GLint *) (pc + 44),
   3426                  *(GLsizei *) (pc + 48),
   3427                  *(GLsizei *) (pc + 52),
   3428                  *(GLsizei *) (pc + 56),
   3429                  *(GLint *) (pc + 64),
   3430                  *(GLenum *) (pc + 68), *(GLenum *) (pc + 72), pixels);
   3431 }
   3432 
   3433 void
   3434 __glXDisp_TexSubImage3D(GLbyte * pc)
   3435 {
   3436     const GLvoid *const pixels = (const GLvoid *) ((pc + 88));
   3437     __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
   3438 
   3439     glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
   3440     glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
   3441     glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
   3442     glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight);
   3443     glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
   3444     glPixelStorei(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages);
   3445     glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
   3446     glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
   3447 
   3448     glTexSubImage3D(*(GLenum *) (pc + 36),
   3449                     *(GLint *) (pc + 40),
   3450                     *(GLint *) (pc + 44),
   3451                     *(GLint *) (pc + 48),
   3452                     *(GLint *) (pc + 52),
   3453                     *(GLsizei *) (pc + 60),
   3454                     *(GLsizei *) (pc + 64),
   3455                     *(GLsizei *) (pc + 68),
   3456                     *(GLenum *) (pc + 76), *(GLenum *) (pc + 80), pixels);
   3457 }
   3458 
   3459 void
   3460 __glXDisp_CopyTexSubImage3D(GLbyte * pc)
   3461 {
   3462     glCopyTexSubImage3D(*(GLenum *) (pc + 0),
   3463                         *(GLint *) (pc + 4),
   3464                         *(GLint *) (pc + 8),
   3465                         *(GLint *) (pc + 12),
   3466                         *(GLint *) (pc + 16),
   3467                         *(GLint *) (pc + 20),
   3468                         *(GLint *) (pc + 24),
   3469                         *(GLsizei *) (pc + 28), *(GLsizei *) (pc + 32));
   3470 }
   3471 
   3472 void
   3473 __glXDisp_ActiveTexture(GLbyte * pc)
   3474 {
   3475     glActiveTextureARB(*(GLenum *) (pc + 0));
   3476 }
   3477 
   3478 void
   3479 __glXDisp_MultiTexCoord1dv(GLbyte * pc)
   3480 {
   3481 #ifdef __GLX_ALIGN64
   3482     if ((unsigned long) (pc) & 7) {
   3483         (void) memmove(pc - 4, pc, 12);
   3484         pc -= 4;
   3485     }
   3486 #endif
   3487 
   3488     glMultiTexCoord1dvARB(*(GLenum *) (pc + 8), (const GLdouble *) (pc + 0));
   3489 }
   3490 
   3491 void
   3492 __glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
   3493 {
   3494     glMultiTexCoord1fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
   3495 }
   3496 
   3497 void
   3498 __glXDisp_MultiTexCoord1iv(GLbyte * pc)
   3499 {
   3500     glMultiTexCoord1ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
   3501 }
   3502 
   3503 void
   3504 __glXDisp_MultiTexCoord1sv(GLbyte * pc)
   3505 {
   3506     glMultiTexCoord1svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
   3507 }
   3508 
   3509 void
   3510 __glXDisp_MultiTexCoord2dv(GLbyte * pc)
   3511 {
   3512 #ifdef __GLX_ALIGN64
   3513     if ((unsigned long) (pc) & 7) {
   3514         (void) memmove(pc - 4, pc, 20);
   3515         pc -= 4;
   3516     }
   3517 #endif
   3518 
   3519     glMultiTexCoord2dvARB(*(GLenum *) (pc + 16), (const GLdouble *) (pc + 0));
   3520 }
   3521 
   3522 void
   3523 __glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
   3524 {
   3525     glMultiTexCoord2fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
   3526 }
   3527 
   3528 void
   3529 __glXDisp_MultiTexCoord2iv(GLbyte * pc)
   3530 {
   3531     glMultiTexCoord2ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
   3532 }
   3533 
   3534 void
   3535 __glXDisp_MultiTexCoord2sv(GLbyte * pc)
   3536 {
   3537     glMultiTexCoord2svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
   3538 }
   3539 
   3540 void
   3541 __glXDisp_MultiTexCoord3dv(GLbyte * pc)
   3542 {
   3543 #ifdef __GLX_ALIGN64
   3544     if ((unsigned long) (pc) & 7) {
   3545         (void) memmove(pc - 4, pc, 28);
   3546         pc -= 4;
   3547     }
   3548 #endif
   3549 
   3550     glMultiTexCoord3dvARB(*(GLenum *) (pc + 24), (const GLdouble *) (pc + 0));
   3551 }
   3552 
   3553 void
   3554 __glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
   3555 {
   3556     glMultiTexCoord3fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
   3557 }
   3558 
   3559 void
   3560 __glXDisp_MultiTexCoord3iv(GLbyte * pc)
   3561 {
   3562     glMultiTexCoord3ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
   3563 }
   3564 
   3565 void
   3566 __glXDisp_MultiTexCoord3sv(GLbyte * pc)
   3567 {
   3568     glMultiTexCoord3svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
   3569 }
   3570 
   3571 void
   3572 __glXDisp_MultiTexCoord4dv(GLbyte * pc)
   3573 {
   3574 #ifdef __GLX_ALIGN64
   3575     if ((unsigned long) (pc) & 7) {
   3576         (void) memmove(pc - 4, pc, 36);
   3577         pc -= 4;
   3578     }
   3579 #endif
   3580 
   3581     glMultiTexCoord4dvARB(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0));
   3582 }
   3583 
   3584 void
   3585 __glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
   3586 {
   3587     glMultiTexCoord4fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
   3588 }
   3589 
   3590 void
   3591 __glXDisp_MultiTexCoord4iv(GLbyte * pc)
   3592 {
   3593     glMultiTexCoord4ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
   3594 }
   3595 
   3596 void
   3597 __glXDisp_MultiTexCoord4sv(GLbyte * pc)
   3598 {
   3599     glMultiTexCoord4svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
   3600 }
   3601 
   3602 void
   3603 __glXDisp_CompressedTexImage1D(GLbyte * pc)
   3604 {
   3605     PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D =
   3606         __glGetProcAddress("glCompressedTexImage1D");
   3607     const GLsizei imageSize = *(GLsizei *) (pc + 20);
   3608 
   3609     CompressedTexImage1D(*(GLenum *) (pc + 0),
   3610                          *(GLint *) (pc + 4),
   3611                          *(GLenum *) (pc + 8),
   3612                          *(GLsizei *) (pc + 12),
   3613                          *(GLint *) (pc + 16),
   3614                          imageSize, (const GLvoid *) (pc + 24));
   3615 }
   3616 
   3617 void
   3618 __glXDisp_CompressedTexImage2D(GLbyte * pc)
   3619 {
   3620     PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D =
   3621         __glGetProcAddress("glCompressedTexImage2D");
   3622     const GLsizei imageSize = *(GLsizei *) (pc + 24);
   3623 
   3624     CompressedTexImage2D(*(GLenum *) (pc + 0),
   3625                          *(GLint *) (pc + 4),
   3626                          *(GLenum *) (pc + 8),
   3627                          *(GLsizei *) (pc + 12),
   3628                          *(GLsizei *) (pc + 16),
   3629                          *(GLint *) (pc + 20),
   3630                          imageSize, (const GLvoid *) (pc + 28));
   3631 }
   3632 
   3633 void
   3634 __glXDisp_CompressedTexImage3D(GLbyte * pc)
   3635 {
   3636     PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D =
   3637         __glGetProcAddress("glCompressedTexImage3D");
   3638     const GLsizei imageSize = *(GLsizei *) (pc + 28);
   3639 
   3640     CompressedTexImage3D(*(GLenum *) (pc + 0),
   3641                          *(GLint *) (pc + 4),
   3642                          *(GLenum *) (pc + 8),
   3643                          *(GLsizei *) (pc + 12),
   3644                          *(GLsizei *) (pc + 16),
   3645                          *(GLsizei *) (pc + 20),
   3646                          *(GLint *) (pc + 24),
   3647                          imageSize, (const GLvoid *) (pc + 32));
   3648 }
   3649 
   3650 void
   3651 __glXDisp_CompressedTexSubImage1D(GLbyte * pc)
   3652 {
   3653     PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D =
   3654         __glGetProcAddress("glCompressedTexSubImage1D");
   3655     const GLsizei imageSize = *(GLsizei *) (pc + 20);
   3656 
   3657     CompressedTexSubImage1D(*(GLenum *) (pc + 0),
   3658                             *(GLint *) (pc + 4),
   3659                             *(GLint *) (pc + 8),
   3660                             *(GLsizei *) (pc + 12),
   3661                             *(GLenum *) (pc + 16),
   3662                             imageSize, (const GLvoid *) (pc + 24));
   3663 }
   3664 
   3665 void
   3666 __glXDisp_CompressedTexSubImage2D(GLbyte * pc)
   3667 {
   3668     PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D =
   3669         __glGetProcAddress("glCompressedTexSubImage2D");
   3670     const GLsizei imageSize = *(GLsizei *) (pc + 28);
   3671 
   3672     CompressedTexSubImage2D(*(GLenum *) (pc + 0),
   3673                             *(GLint *) (pc + 4),
   3674                             *(GLint *) (pc + 8),
   3675                             *(GLint *) (pc + 12),
   3676                             *(GLsizei *) (pc + 16),
   3677                             *(GLsizei *) (pc + 20),
   3678                             *(GLenum *) (pc + 24),
   3679                             imageSize, (const GLvoid *) (pc + 32));
   3680 }
   3681 
   3682 void
   3683 __glXDisp_CompressedTexSubImage3D(GLbyte * pc)
   3684 {
   3685     PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D =
   3686         __glGetProcAddress("glCompressedTexSubImage3D");
   3687     const GLsizei imageSize = *(GLsizei *) (pc + 36);
   3688 
   3689     CompressedTexSubImage3D(*(GLenum *) (pc + 0),
   3690                             *(GLint *) (pc + 4),
   3691                             *(GLint *) (pc + 8),
   3692                             *(GLint *) (pc + 12),
   3693                             *(GLint *) (pc + 16),
   3694                             *(GLsizei *) (pc + 20),
   3695                             *(GLsizei *) (pc + 24),
   3696                             *(GLsizei *) (pc + 28),
   3697                             *(GLenum *) (pc + 32),
   3698                             imageSize, (const GLvoid *) (pc + 40));
   3699 }
   3700 
   3701 void
   3702 __glXDisp_SampleCoverage(GLbyte * pc)
   3703 {
   3704     PFNGLSAMPLECOVERAGEPROC SampleCoverage =
   3705         __glGetProcAddress("glSampleCoverage");
   3706     SampleCoverage(*(GLclampf *) (pc + 0), *(GLboolean *) (pc + 4));
   3707 }
   3708 
   3709 void
   3710 __glXDisp_BlendFuncSeparate(GLbyte * pc)
   3711 {
   3712     PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate =
   3713         __glGetProcAddress("glBlendFuncSeparate");
   3714     BlendFuncSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   3715                       *(GLenum *) (pc + 8), *(GLenum *) (pc + 12));
   3716 }
   3717 
   3718 void
   3719 __glXDisp_FogCoorddv(GLbyte * pc)
   3720 {
   3721     PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
   3722 
   3723 #ifdef __GLX_ALIGN64
   3724     if ((unsigned long) (pc) & 7) {
   3725         (void) memmove(pc - 4, pc, 8);
   3726         pc -= 4;
   3727     }
   3728 #endif
   3729 
   3730     FogCoorddv((const GLdouble *) (pc + 0));
   3731 }
   3732 
   3733 void
   3734 __glXDisp_PointParameterf(GLbyte * pc)
   3735 {
   3736     PFNGLPOINTPARAMETERFPROC PointParameterf =
   3737         __glGetProcAddress("glPointParameterf");
   3738     PointParameterf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
   3739 }
   3740 
   3741 void
   3742 __glXDisp_PointParameterfv(GLbyte * pc)
   3743 {
   3744     PFNGLPOINTPARAMETERFVPROC PointParameterfv =
   3745         __glGetProcAddress("glPointParameterfv");
   3746     const GLenum pname = *(GLenum *) (pc + 0);
   3747     const GLfloat *params;
   3748 
   3749     params = (const GLfloat *) (pc + 4);
   3750 
   3751     PointParameterfv(pname, params);
   3752 }
   3753 
   3754 void
   3755 __glXDisp_PointParameteri(GLbyte * pc)
   3756 {
   3757     PFNGLPOINTPARAMETERIPROC PointParameteri =
   3758         __glGetProcAddress("glPointParameteri");
   3759     PointParameteri(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
   3760 }
   3761 
   3762 void
   3763 __glXDisp_PointParameteriv(GLbyte * pc)
   3764 {
   3765     PFNGLPOINTPARAMETERIVPROC PointParameteriv =
   3766         __glGetProcAddress("glPointParameteriv");
   3767     const GLenum pname = *(GLenum *) (pc + 0);
   3768     const GLint *params;
   3769 
   3770     params = (const GLint *) (pc + 4);
   3771 
   3772     PointParameteriv(pname, params);
   3773 }
   3774 
   3775 void
   3776 __glXDisp_SecondaryColor3bv(GLbyte * pc)
   3777 {
   3778     PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
   3779         __glGetProcAddress("glSecondaryColor3bv");
   3780     SecondaryColor3bv((const GLbyte *) (pc + 0));
   3781 }
   3782 
   3783 void
   3784 __glXDisp_SecondaryColor3dv(GLbyte * pc)
   3785 {
   3786     PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
   3787         __glGetProcAddress("glSecondaryColor3dv");
   3788 #ifdef __GLX_ALIGN64
   3789     if ((unsigned long) (pc) & 7) {
   3790         (void) memmove(pc - 4, pc, 24);
   3791         pc -= 4;
   3792     }
   3793 #endif
   3794 
   3795     SecondaryColor3dv((const GLdouble *) (pc + 0));
   3796 }
   3797 
   3798 void
   3799 __glXDisp_SecondaryColor3iv(GLbyte * pc)
   3800 {
   3801     PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv =
   3802         __glGetProcAddress("glSecondaryColor3iv");
   3803     SecondaryColor3iv((const GLint *) (pc + 0));
   3804 }
   3805 
   3806 void
   3807 __glXDisp_SecondaryColor3sv(GLbyte * pc)
   3808 {
   3809     PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv =
   3810         __glGetProcAddress("glSecondaryColor3sv");
   3811     SecondaryColor3sv((const GLshort *) (pc + 0));
   3812 }
   3813 
   3814 void
   3815 __glXDisp_SecondaryColor3ubv(GLbyte * pc)
   3816 {
   3817     PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
   3818         __glGetProcAddress("glSecondaryColor3ubv");
   3819     SecondaryColor3ubv((const GLubyte *) (pc + 0));
   3820 }
   3821 
   3822 void
   3823 __glXDisp_SecondaryColor3uiv(GLbyte * pc)
   3824 {
   3825     PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv =
   3826         __glGetProcAddress("glSecondaryColor3uiv");
   3827     SecondaryColor3uiv((const GLuint *) (pc + 0));
   3828 }
   3829 
   3830 void
   3831 __glXDisp_SecondaryColor3usv(GLbyte * pc)
   3832 {
   3833     PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv =
   3834         __glGetProcAddress("glSecondaryColor3usv");
   3835     SecondaryColor3usv((const GLushort *) (pc + 0));
   3836 }
   3837 
   3838 void
   3839 __glXDisp_WindowPos3fv(GLbyte * pc)
   3840 {
   3841     PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv");
   3842 
   3843     WindowPos3fv((const GLfloat *) (pc + 0));
   3844 }
   3845 
   3846 void
   3847 __glXDisp_BeginQuery(GLbyte * pc)
   3848 {
   3849     PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery");
   3850 
   3851     BeginQuery(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
   3852 }
   3853 
   3854 int
   3855 __glXDisp_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
   3856 {
   3857     PFNGLDELETEQUERIESPROC DeleteQueries =
   3858         __glGetProcAddress("glDeleteQueries");
   3859     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3860     int error;
   3861     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3862 
   3863     pc += __GLX_SINGLE_HDR_SIZE;
   3864     if (cx != NULL) {
   3865         const GLsizei n = *(GLsizei *) (pc + 0);
   3866 
   3867         DeleteQueries(n, (const GLuint *) (pc + 4));
   3868         error = Success;
   3869     }
   3870 
   3871     return error;
   3872 }
   3873 
   3874 void
   3875 __glXDisp_EndQuery(GLbyte * pc)
   3876 {
   3877     PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
   3878 
   3879     EndQuery(*(GLenum *) (pc + 0));
   3880 }
   3881 
   3882 int
   3883 __glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc)
   3884 {
   3885     PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries");
   3886     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3887     int error;
   3888     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3889 
   3890     pc += __GLX_SINGLE_HDR_SIZE;
   3891     if (cx != NULL) {
   3892         const GLsizei n = *(GLsizei *) (pc + 0);
   3893 
   3894         GLuint answerBuffer[200];
   3895         GLuint *ids =
   3896             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
   3897                                  4);
   3898 
   3899         if (ids == NULL)
   3900             return BadAlloc;
   3901         GenQueries(n, ids);
   3902         __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
   3903         error = Success;
   3904     }
   3905 
   3906     return error;
   3907 }
   3908 
   3909 int
   3910 __glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
   3911 {
   3912     PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv =
   3913         __glGetProcAddress("glGetQueryObjectiv");
   3914     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3915     int error;
   3916     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3917 
   3918     pc += __GLX_SINGLE_HDR_SIZE;
   3919     if (cx != NULL) {
   3920         const GLenum pname = *(GLenum *) (pc + 4);
   3921 
   3922         const GLuint compsize = __glGetQueryObjectiv_size(pname);
   3923         GLint answerBuffer[200];
   3924         GLint *params =
   3925             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3926                                  sizeof(answerBuffer), 4);
   3927 
   3928         if (params == NULL)
   3929             return BadAlloc;
   3930         __glXClearErrorOccured();
   3931 
   3932         GetQueryObjectiv(*(GLuint *) (pc + 0), pname, params);
   3933         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3934         error = Success;
   3935     }
   3936 
   3937     return error;
   3938 }
   3939 
   3940 int
   3941 __glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
   3942 {
   3943     PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv =
   3944         __glGetProcAddress("glGetQueryObjectuiv");
   3945     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3946     int error;
   3947     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3948 
   3949     pc += __GLX_SINGLE_HDR_SIZE;
   3950     if (cx != NULL) {
   3951         const GLenum pname = *(GLenum *) (pc + 4);
   3952 
   3953         const GLuint compsize = __glGetQueryObjectuiv_size(pname);
   3954         GLuint answerBuffer[200];
   3955         GLuint *params =
   3956             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3957                                  sizeof(answerBuffer), 4);
   3958 
   3959         if (params == NULL)
   3960             return BadAlloc;
   3961         __glXClearErrorOccured();
   3962 
   3963         GetQueryObjectuiv(*(GLuint *) (pc + 0), pname, params);
   3964         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3965         error = Success;
   3966     }
   3967 
   3968     return error;
   3969 }
   3970 
   3971 int
   3972 __glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
   3973 {
   3974     PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv");
   3975     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   3976     int error;
   3977     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   3978 
   3979     pc += __GLX_SINGLE_HDR_SIZE;
   3980     if (cx != NULL) {
   3981         const GLenum pname = *(GLenum *) (pc + 4);
   3982 
   3983         const GLuint compsize = __glGetQueryiv_size(pname);
   3984         GLint answerBuffer[200];
   3985         GLint *params =
   3986             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   3987                                  sizeof(answerBuffer), 4);
   3988 
   3989         if (params == NULL)
   3990             return BadAlloc;
   3991         __glXClearErrorOccured();
   3992 
   3993         GetQueryiv(*(GLenum *) (pc + 0), pname, params);
   3994         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   3995         error = Success;
   3996     }
   3997 
   3998     return error;
   3999 }
   4000 
   4001 int
   4002 __glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc)
   4003 {
   4004     PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery");
   4005     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
   4006     int error;
   4007     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4008 
   4009     pc += __GLX_SINGLE_HDR_SIZE;
   4010     if (cx != NULL) {
   4011         GLboolean retval;
   4012 
   4013         retval = IsQuery(*(GLuint *) (pc + 0));
   4014         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   4015         error = Success;
   4016     }
   4017 
   4018     return error;
   4019 }
   4020 
   4021 void
   4022 __glXDisp_BlendEquationSeparate(GLbyte * pc)
   4023 {
   4024     PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate =
   4025         __glGetProcAddress("glBlendEquationSeparate");
   4026     BlendEquationSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
   4027 }
   4028 
   4029 void
   4030 __glXDisp_DrawBuffers(GLbyte * pc)
   4031 {
   4032     PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers");
   4033     const GLsizei n = *(GLsizei *) (pc + 0);
   4034 
   4035     DrawBuffers(n, (const GLenum *) (pc + 4));
   4036 }
   4037 
   4038 void
   4039 __glXDisp_VertexAttrib1dv(GLbyte * pc)
   4040 {
   4041     PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
   4042         __glGetProcAddress("glVertexAttrib1dv");
   4043 #ifdef __GLX_ALIGN64
   4044     if ((unsigned long) (pc) & 7) {
   4045         (void) memmove(pc - 4, pc, 12);
   4046         pc -= 4;
   4047     }
   4048 #endif
   4049 
   4050     VertexAttrib1dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4051 }
   4052 
   4053 void
   4054 __glXDisp_VertexAttrib1sv(GLbyte * pc)
   4055 {
   4056     PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv =
   4057         __glGetProcAddress("glVertexAttrib1sv");
   4058     VertexAttrib1sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4059 }
   4060 
   4061 void
   4062 __glXDisp_VertexAttrib2dv(GLbyte * pc)
   4063 {
   4064     PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
   4065         __glGetProcAddress("glVertexAttrib2dv");
   4066 #ifdef __GLX_ALIGN64
   4067     if ((unsigned long) (pc) & 7) {
   4068         (void) memmove(pc - 4, pc, 20);
   4069         pc -= 4;
   4070     }
   4071 #endif
   4072 
   4073     VertexAttrib2dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4074 }
   4075 
   4076 void
   4077 __glXDisp_VertexAttrib2sv(GLbyte * pc)
   4078 {
   4079     PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv =
   4080         __glGetProcAddress("glVertexAttrib2sv");
   4081     VertexAttrib2sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4082 }
   4083 
   4084 void
   4085 __glXDisp_VertexAttrib3dv(GLbyte * pc)
   4086 {
   4087     PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
   4088         __glGetProcAddress("glVertexAttrib3dv");
   4089 #ifdef __GLX_ALIGN64
   4090     if ((unsigned long) (pc) & 7) {
   4091         (void) memmove(pc - 4, pc, 28);
   4092         pc -= 4;
   4093     }
   4094 #endif
   4095 
   4096     VertexAttrib3dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4097 }
   4098 
   4099 void
   4100 __glXDisp_VertexAttrib3sv(GLbyte * pc)
   4101 {
   4102     PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv =
   4103         __glGetProcAddress("glVertexAttrib3sv");
   4104     VertexAttrib3sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4105 }
   4106 
   4107 void
   4108 __glXDisp_VertexAttrib4Nbv(GLbyte * pc)
   4109 {
   4110     PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv =
   4111         __glGetProcAddress("glVertexAttrib4Nbv");
   4112     VertexAttrib4Nbv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
   4113 }
   4114 
   4115 void
   4116 __glXDisp_VertexAttrib4Niv(GLbyte * pc)
   4117 {
   4118     PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv =
   4119         __glGetProcAddress("glVertexAttrib4Niv");
   4120     VertexAttrib4Niv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
   4121 }
   4122 
   4123 void
   4124 __glXDisp_VertexAttrib4Nsv(GLbyte * pc)
   4125 {
   4126     PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv =
   4127         __glGetProcAddress("glVertexAttrib4Nsv");
   4128     VertexAttrib4Nsv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4129 }
   4130 
   4131 void
   4132 __glXDisp_VertexAttrib4Nubv(GLbyte * pc)
   4133 {
   4134     PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv =
   4135         __glGetProcAddress("glVertexAttrib4Nubv");
   4136     VertexAttrib4Nubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
   4137 }
   4138 
   4139 void
   4140 __glXDisp_VertexAttrib4Nuiv(GLbyte * pc)
   4141 {
   4142     PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv =
   4143         __glGetProcAddress("glVertexAttrib4Nuiv");
   4144     VertexAttrib4Nuiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
   4145 }
   4146 
   4147 void
   4148 __glXDisp_VertexAttrib4Nusv(GLbyte * pc)
   4149 {
   4150     PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv =
   4151         __glGetProcAddress("glVertexAttrib4Nusv");
   4152     VertexAttrib4Nusv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
   4153 }
   4154 
   4155 void
   4156 __glXDisp_VertexAttrib4bv(GLbyte * pc)
   4157 {
   4158     PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv =
   4159         __glGetProcAddress("glVertexAttrib4bv");
   4160     VertexAttrib4bv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
   4161 }
   4162 
   4163 void
   4164 __glXDisp_VertexAttrib4dv(GLbyte * pc)
   4165 {
   4166     PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
   4167         __glGetProcAddress("glVertexAttrib4dv");
   4168 #ifdef __GLX_ALIGN64
   4169     if ((unsigned long) (pc) & 7) {
   4170         (void) memmove(pc - 4, pc, 36);
   4171         pc -= 4;
   4172     }
   4173 #endif
   4174 
   4175     VertexAttrib4dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4176 }
   4177 
   4178 void
   4179 __glXDisp_VertexAttrib4iv(GLbyte * pc)
   4180 {
   4181     PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv =
   4182         __glGetProcAddress("glVertexAttrib4iv");
   4183     VertexAttrib4iv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
   4184 }
   4185 
   4186 void
   4187 __glXDisp_VertexAttrib4sv(GLbyte * pc)
   4188 {
   4189     PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv =
   4190         __glGetProcAddress("glVertexAttrib4sv");
   4191     VertexAttrib4sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4192 }
   4193 
   4194 void
   4195 __glXDisp_VertexAttrib4ubv(GLbyte * pc)
   4196 {
   4197     PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv =
   4198         __glGetProcAddress("glVertexAttrib4ubv");
   4199     VertexAttrib4ubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
   4200 }
   4201 
   4202 void
   4203 __glXDisp_VertexAttrib4uiv(GLbyte * pc)
   4204 {
   4205     PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv =
   4206         __glGetProcAddress("glVertexAttrib4uiv");
   4207     VertexAttrib4uiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
   4208 }
   4209 
   4210 void
   4211 __glXDisp_VertexAttrib4usv(GLbyte * pc)
   4212 {
   4213     PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv =
   4214         __glGetProcAddress("glVertexAttrib4usv");
   4215     VertexAttrib4usv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
   4216 }
   4217 
   4218 void
   4219 __glXDisp_ClampColor(GLbyte * pc)
   4220 {
   4221     PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor");
   4222 
   4223     ClampColor(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
   4224 }
   4225 
   4226 void
   4227 __glXDisp_BindProgramARB(GLbyte * pc)
   4228 {
   4229     PFNGLBINDPROGRAMARBPROC BindProgramARB =
   4230         __glGetProcAddress("glBindProgramARB");
   4231     BindProgramARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
   4232 }
   4233 
   4234 int
   4235 __glXDisp_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
   4236 {
   4237     PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB =
   4238         __glGetProcAddress("glDeleteProgramsARB");
   4239     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4240     int error;
   4241     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4242 
   4243     pc += __GLX_VENDPRIV_HDR_SIZE;
   4244     if (cx != NULL) {
   4245         const GLsizei n = *(GLsizei *) (pc + 0);
   4246 
   4247         DeleteProgramsARB(n, (const GLuint *) (pc + 4));
   4248         error = Success;
   4249     }
   4250 
   4251     return error;
   4252 }
   4253 
   4254 int
   4255 __glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
   4256 {
   4257     PFNGLGENPROGRAMSARBPROC GenProgramsARB =
   4258         __glGetProcAddress("glGenProgramsARB");
   4259     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4260     int error;
   4261     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4262 
   4263     pc += __GLX_VENDPRIV_HDR_SIZE;
   4264     if (cx != NULL) {
   4265         const GLsizei n = *(GLsizei *) (pc + 0);
   4266 
   4267         GLuint answerBuffer[200];
   4268         GLuint *programs =
   4269             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
   4270                                  4);
   4271 
   4272         if (programs == NULL)
   4273             return BadAlloc;
   4274         GenProgramsARB(n, programs);
   4275         __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0);
   4276         error = Success;
   4277     }
   4278 
   4279     return error;
   4280 }
   4281 
   4282 int
   4283 __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
   4284 {
   4285     PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB =
   4286         __glGetProcAddress("glGetProgramEnvParameterdvARB");
   4287     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4288     int error;
   4289     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4290 
   4291     pc += __GLX_VENDPRIV_HDR_SIZE;
   4292     if (cx != NULL) {
   4293         GLdouble params[4];
   4294 
   4295         GetProgramEnvParameterdvARB(*(GLenum *) (pc + 0),
   4296                                     *(GLuint *) (pc + 4), params);
   4297         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
   4298         error = Success;
   4299     }
   4300 
   4301     return error;
   4302 }
   4303 
   4304 int
   4305 __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
   4306 {
   4307     PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB =
   4308         __glGetProcAddress("glGetProgramEnvParameterfvARB");
   4309     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4310     int error;
   4311     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4312 
   4313     pc += __GLX_VENDPRIV_HDR_SIZE;
   4314     if (cx != NULL) {
   4315         GLfloat params[4];
   4316 
   4317         GetProgramEnvParameterfvARB(*(GLenum *) (pc + 0),
   4318                                     *(GLuint *) (pc + 4), params);
   4319         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
   4320         error = Success;
   4321     }
   4322 
   4323     return error;
   4324 }
   4325 
   4326 int
   4327 __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
   4328 {
   4329     PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB =
   4330         __glGetProcAddress("glGetProgramLocalParameterdvARB");
   4331     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4332     int error;
   4333     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4334 
   4335     pc += __GLX_VENDPRIV_HDR_SIZE;
   4336     if (cx != NULL) {
   4337         GLdouble params[4];
   4338 
   4339         GetProgramLocalParameterdvARB(*(GLenum *) (pc + 0),
   4340                                       *(GLuint *) (pc + 4), params);
   4341         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
   4342         error = Success;
   4343     }
   4344 
   4345     return error;
   4346 }
   4347 
   4348 int
   4349 __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
   4350 {
   4351     PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB =
   4352         __glGetProcAddress("glGetProgramLocalParameterfvARB");
   4353     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4354     int error;
   4355     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4356 
   4357     pc += __GLX_VENDPRIV_HDR_SIZE;
   4358     if (cx != NULL) {
   4359         GLfloat params[4];
   4360 
   4361         GetProgramLocalParameterfvARB(*(GLenum *) (pc + 0),
   4362                                       *(GLuint *) (pc + 4), params);
   4363         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
   4364         error = Success;
   4365     }
   4366 
   4367     return error;
   4368 }
   4369 
   4370 int
   4371 __glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
   4372 {
   4373     PFNGLGETPROGRAMIVARBPROC GetProgramivARB =
   4374         __glGetProcAddress("glGetProgramivARB");
   4375     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4376     int error;
   4377     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4378 
   4379     pc += __GLX_VENDPRIV_HDR_SIZE;
   4380     if (cx != NULL) {
   4381         const GLenum pname = *(GLenum *) (pc + 4);
   4382 
   4383         const GLuint compsize = __glGetProgramivARB_size(pname);
   4384         GLint answerBuffer[200];
   4385         GLint *params =
   4386             __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
   4387                                  sizeof(answerBuffer), 4);
   4388 
   4389         if (params == NULL)
   4390             return BadAlloc;
   4391         __glXClearErrorOccured();
   4392 
   4393         GetProgramivARB(*(GLenum *) (pc + 0), pname, params);
   4394         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
   4395         error = Success;
   4396     }
   4397 
   4398     return error;
   4399 }
   4400 
   4401 int
   4402 __glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
   4403 {
   4404     PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB");
   4405     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4406     int error;
   4407     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4408 
   4409     pc += __GLX_VENDPRIV_HDR_SIZE;
   4410     if (cx != NULL) {
   4411         GLboolean retval;
   4412 
   4413         retval = IsProgramARB(*(GLuint *) (pc + 0));
   4414         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   4415         error = Success;
   4416     }
   4417 
   4418     return error;
   4419 }
   4420 
   4421 void
   4422 __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
   4423 {
   4424     PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
   4425         __glGetProcAddress("glProgramEnvParameter4dvARB");
   4426 #ifdef __GLX_ALIGN64
   4427     if ((unsigned long) (pc) & 7) {
   4428         (void) memmove(pc - 4, pc, 40);
   4429         pc -= 4;
   4430     }
   4431 #endif
   4432 
   4433     ProgramEnvParameter4dvARB(*(GLenum *) (pc + 0),
   4434                               *(GLuint *) (pc + 4),
   4435                               (const GLdouble *) (pc + 8));
   4436 }
   4437 
   4438 void
   4439 __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
   4440 {
   4441     PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB =
   4442         __glGetProcAddress("glProgramEnvParameter4fvARB");
   4443     ProgramEnvParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4),
   4444                               (const GLfloat *) (pc + 8));
   4445 }
   4446 
   4447 void
   4448 __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
   4449 {
   4450     PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
   4451         __glGetProcAddress("glProgramLocalParameter4dvARB");
   4452 #ifdef __GLX_ALIGN64
   4453     if ((unsigned long) (pc) & 7) {
   4454         (void) memmove(pc - 4, pc, 40);
   4455         pc -= 4;
   4456     }
   4457 #endif
   4458 
   4459     ProgramLocalParameter4dvARB(*(GLenum *) (pc + 0),
   4460                                 *(GLuint *) (pc + 4),
   4461                                 (const GLdouble *) (pc + 8));
   4462 }
   4463 
   4464 void
   4465 __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
   4466 {
   4467     PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB =
   4468         __glGetProcAddress("glProgramLocalParameter4fvARB");
   4469     ProgramLocalParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4),
   4470                                 (const GLfloat *) (pc + 8));
   4471 }
   4472 
   4473 void
   4474 __glXDisp_ProgramStringARB(GLbyte * pc)
   4475 {
   4476     PFNGLPROGRAMSTRINGARBPROC ProgramStringARB =
   4477         __glGetProcAddress("glProgramStringARB");
   4478     const GLsizei len = *(GLsizei *) (pc + 8);
   4479 
   4480     ProgramStringARB(*(GLenum *) (pc + 0),
   4481                      *(GLenum *) (pc + 4), len, (const GLvoid *) (pc + 12));
   4482 }
   4483 
   4484 void
   4485 __glXDisp_VertexAttrib1fvARB(GLbyte * pc)
   4486 {
   4487     PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB =
   4488         __glGetProcAddress("glVertexAttrib1fvARB");
   4489     VertexAttrib1fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4490 }
   4491 
   4492 void
   4493 __glXDisp_VertexAttrib2fvARB(GLbyte * pc)
   4494 {
   4495     PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB =
   4496         __glGetProcAddress("glVertexAttrib2fvARB");
   4497     VertexAttrib2fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4498 }
   4499 
   4500 void
   4501 __glXDisp_VertexAttrib3fvARB(GLbyte * pc)
   4502 {
   4503     PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB =
   4504         __glGetProcAddress("glVertexAttrib3fvARB");
   4505     VertexAttrib3fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4506 }
   4507 
   4508 void
   4509 __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
   4510 {
   4511     PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB =
   4512         __glGetProcAddress("glVertexAttrib4fvARB");
   4513     VertexAttrib4fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4514 }
   4515 
   4516 void
   4517 __glXDisp_BindFramebuffer(GLbyte * pc)
   4518 {
   4519     PFNGLBINDFRAMEBUFFERPROC BindFramebuffer =
   4520         __glGetProcAddress("glBindFramebuffer");
   4521     BindFramebuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
   4522 }
   4523 
   4524 void
   4525 __glXDisp_BindRenderbuffer(GLbyte * pc)
   4526 {
   4527     PFNGLBINDRENDERBUFFERPROC BindRenderbuffer =
   4528         __glGetProcAddress("glBindRenderbuffer");
   4529     BindRenderbuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
   4530 }
   4531 
   4532 void
   4533 __glXDisp_BlitFramebuffer(GLbyte * pc)
   4534 {
   4535     PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer =
   4536         __glGetProcAddress("glBlitFramebuffer");
   4537     BlitFramebuffer(*(GLint *) (pc + 0), *(GLint *) (pc + 4),
   4538                     *(GLint *) (pc + 8), *(GLint *) (pc + 12),
   4539                     *(GLint *) (pc + 16), *(GLint *) (pc + 20),
   4540                     *(GLint *) (pc + 24), *(GLint *) (pc + 28),
   4541                     *(GLbitfield *) (pc + 32), *(GLenum *) (pc + 36));
   4542 }
   4543 
   4544 int
   4545 __glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
   4546 {
   4547     PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus =
   4548         __glGetProcAddress("glCheckFramebufferStatus");
   4549     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4550     int error;
   4551     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4552 
   4553     pc += __GLX_VENDPRIV_HDR_SIZE;
   4554     if (cx != NULL) {
   4555         GLenum retval;
   4556 
   4557         retval = CheckFramebufferStatus(*(GLenum *) (pc + 0));
   4558         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   4559         error = Success;
   4560     }
   4561 
   4562     return error;
   4563 }
   4564 
   4565 void
   4566 __glXDisp_DeleteFramebuffers(GLbyte * pc)
   4567 {
   4568     PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers =
   4569         __glGetProcAddress("glDeleteFramebuffers");
   4570     const GLsizei n = *(GLsizei *) (pc + 0);
   4571 
   4572     DeleteFramebuffers(n, (const GLuint *) (pc + 4));
   4573 }
   4574 
   4575 void
   4576 __glXDisp_DeleteRenderbuffers(GLbyte * pc)
   4577 {
   4578     PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers =
   4579         __glGetProcAddress("glDeleteRenderbuffers");
   4580     const GLsizei n = *(GLsizei *) (pc + 0);
   4581 
   4582     DeleteRenderbuffers(n, (const GLuint *) (pc + 4));
   4583 }
   4584 
   4585 void
   4586 __glXDisp_FramebufferRenderbuffer(GLbyte * pc)
   4587 {
   4588     PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer =
   4589         __glGetProcAddress("glFramebufferRenderbuffer");
   4590     FramebufferRenderbuffer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   4591                             *(GLenum *) (pc + 8), *(GLuint *) (pc + 12));
   4592 }
   4593 
   4594 void
   4595 __glXDisp_FramebufferTexture1D(GLbyte * pc)
   4596 {
   4597     PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D =
   4598         __glGetProcAddress("glFramebufferTexture1D");
   4599     FramebufferTexture1D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   4600                          *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
   4601                          *(GLint *) (pc + 16));
   4602 }
   4603 
   4604 void
   4605 __glXDisp_FramebufferTexture2D(GLbyte * pc)
   4606 {
   4607     PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D =
   4608         __glGetProcAddress("glFramebufferTexture2D");
   4609     FramebufferTexture2D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   4610                          *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
   4611                          *(GLint *) (pc + 16));
   4612 }
   4613 
   4614 void
   4615 __glXDisp_FramebufferTexture3D(GLbyte * pc)
   4616 {
   4617     PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D =
   4618         __glGetProcAddress("glFramebufferTexture3D");
   4619     FramebufferTexture3D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   4620                          *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
   4621                          *(GLint *) (pc + 16), *(GLint *) (pc + 20));
   4622 }
   4623 
   4624 void
   4625 __glXDisp_FramebufferTextureLayer(GLbyte * pc)
   4626 {
   4627     PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer =
   4628         __glGetProcAddress("glFramebufferTextureLayer");
   4629     FramebufferTextureLayer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   4630                             *(GLuint *) (pc + 8), *(GLint *) (pc + 12),
   4631                             *(GLint *) (pc + 16));
   4632 }
   4633 
   4634 int
   4635 __glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
   4636 {
   4637     PFNGLGENFRAMEBUFFERSPROC GenFramebuffers =
   4638         __glGetProcAddress("glGenFramebuffers");
   4639     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4640     int error;
   4641     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4642 
   4643     pc += __GLX_VENDPRIV_HDR_SIZE;
   4644     if (cx != NULL) {
   4645         const GLsizei n = *(GLsizei *) (pc + 0);
   4646 
   4647         GLuint answerBuffer[200];
   4648         GLuint *framebuffers =
   4649             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
   4650                                  4);
   4651 
   4652         if (framebuffers == NULL)
   4653             return BadAlloc;
   4654 
   4655         GenFramebuffers(n, framebuffers);
   4656         __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
   4657         error = Success;
   4658     }
   4659 
   4660     return error;
   4661 }
   4662 
   4663 int
   4664 __glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
   4665 {
   4666     PFNGLGENRENDERBUFFERSPROC GenRenderbuffers =
   4667         __glGetProcAddress("glGenRenderbuffers");
   4668     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4669     int error;
   4670     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4671 
   4672     pc += __GLX_VENDPRIV_HDR_SIZE;
   4673     if (cx != NULL) {
   4674         const GLsizei n = *(GLsizei *) (pc + 0);
   4675 
   4676         GLuint answerBuffer[200];
   4677         GLuint *renderbuffers =
   4678             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
   4679                                  4);
   4680 
   4681         if (renderbuffers == NULL)
   4682             return BadAlloc;
   4683         GenRenderbuffers(n, renderbuffers);
   4684         __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
   4685         error = Success;
   4686     }
   4687 
   4688     return error;
   4689 }
   4690 
   4691 void
   4692 __glXDisp_GenerateMipmap(GLbyte * pc)
   4693 {
   4694     PFNGLGENERATEMIPMAPPROC GenerateMipmap =
   4695         __glGetProcAddress("glGenerateMipmap");
   4696     GenerateMipmap(*(GLenum *) (pc + 0));
   4697 }
   4698 
   4699 int
   4700 __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
   4701                                               GLbyte * pc)
   4702 {
   4703     PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
   4704         GetFramebufferAttachmentParameteriv =
   4705         __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
   4706     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4707     int error;
   4708     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4709 
   4710     pc += __GLX_VENDPRIV_HDR_SIZE;
   4711     if (cx != NULL) {
   4712         GLint params[1];
   4713 
   4714         GetFramebufferAttachmentParameteriv(*(GLenum *) (pc + 0),
   4715                                             *(GLenum *) (pc + 4),
   4716                                             *(GLenum *) (pc + 8), params);
   4717         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
   4718         error = Success;
   4719     }
   4720 
   4721     return error;
   4722 }
   4723 
   4724 int
   4725 __glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
   4726 {
   4727     PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv =
   4728         __glGetProcAddress("glGetRenderbufferParameteriv");
   4729     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4730     int error;
   4731     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4732 
   4733     pc += __GLX_VENDPRIV_HDR_SIZE;
   4734     if (cx != NULL) {
   4735         GLint params[1];
   4736 
   4737         GetRenderbufferParameteriv(*(GLenum *) (pc + 0),
   4738                                    *(GLenum *) (pc + 4), params);
   4739         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
   4740         error = Success;
   4741     }
   4742 
   4743     return error;
   4744 }
   4745 
   4746 int
   4747 __glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
   4748 {
   4749     PFNGLISFRAMEBUFFERPROC IsFramebuffer =
   4750         __glGetProcAddress("glIsFramebuffer");
   4751     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4752     int error;
   4753     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4754 
   4755     pc += __GLX_VENDPRIV_HDR_SIZE;
   4756     if (cx != NULL) {
   4757         GLboolean retval;
   4758 
   4759         retval = IsFramebuffer(*(GLuint *) (pc + 0));
   4760         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   4761         error = Success;
   4762     }
   4763 
   4764     return error;
   4765 }
   4766 
   4767 int
   4768 __glXDisp_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
   4769 {
   4770     PFNGLISRENDERBUFFERPROC IsRenderbuffer =
   4771         __glGetProcAddress("glIsRenderbuffer");
   4772     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
   4773     int error;
   4774     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
   4775 
   4776     pc += __GLX_VENDPRIV_HDR_SIZE;
   4777     if (cx != NULL) {
   4778         GLboolean retval;
   4779 
   4780         retval = IsRenderbuffer(*(GLuint *) (pc + 0));
   4781         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
   4782         error = Success;
   4783     }
   4784 
   4785     return error;
   4786 }
   4787 
   4788 void
   4789 __glXDisp_RenderbufferStorage(GLbyte * pc)
   4790 {
   4791     PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage =
   4792         __glGetProcAddress("glRenderbufferStorage");
   4793     RenderbufferStorage(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
   4794                         *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
   4795 }
   4796 
   4797 void
   4798 __glXDisp_RenderbufferStorageMultisample(GLbyte * pc)
   4799 {
   4800     PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample =
   4801         __glGetProcAddress("glRenderbufferStorageMultisample");
   4802     RenderbufferStorageMultisample(*(GLenum *) (pc + 0), *(GLsizei *) (pc + 4),
   4803                                    *(GLenum *) (pc + 8), *(GLsizei *) (pc + 12),
   4804                                    *(GLsizei *) (pc + 16));
   4805 }
   4806 
   4807 void
   4808 __glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
   4809 {
   4810     PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT =
   4811         __glGetProcAddress("glSecondaryColor3fvEXT");
   4812     SecondaryColor3fvEXT((const GLfloat *) (pc + 0));
   4813 }
   4814 
   4815 void
   4816 __glXDisp_FogCoordfvEXT(GLbyte * pc)
   4817 {
   4818     PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT =
   4819         __glGetProcAddress("glFogCoordfvEXT");
   4820     FogCoordfvEXT((const GLfloat *) (pc + 0));
   4821 }
   4822 
   4823 void
   4824 __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
   4825 {
   4826     PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
   4827         __glGetProcAddress("glVertexAttrib1dvNV");
   4828 #ifdef __GLX_ALIGN64
   4829     if ((unsigned long) (pc) & 7) {
   4830         (void) memmove(pc - 4, pc, 12);
   4831         pc -= 4;
   4832     }
   4833 #endif
   4834 
   4835     VertexAttrib1dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4836 }
   4837 
   4838 void
   4839 __glXDisp_VertexAttrib1fvNV(GLbyte * pc)
   4840 {
   4841     PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV =
   4842         __glGetProcAddress("glVertexAttrib1fvNV");
   4843     VertexAttrib1fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4844 }
   4845 
   4846 void
   4847 __glXDisp_VertexAttrib1svNV(GLbyte * pc)
   4848 {
   4849     PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV =
   4850         __glGetProcAddress("glVertexAttrib1svNV");
   4851     VertexAttrib1svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4852 }
   4853 
   4854 void
   4855 __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
   4856 {
   4857     PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
   4858         __glGetProcAddress("glVertexAttrib2dvNV");
   4859 #ifdef __GLX_ALIGN64
   4860     if ((unsigned long) (pc) & 7) {
   4861         (void) memmove(pc - 4, pc, 20);
   4862         pc -= 4;
   4863     }
   4864 #endif
   4865 
   4866     VertexAttrib2dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4867 }
   4868 
   4869 void
   4870 __glXDisp_VertexAttrib2fvNV(GLbyte * pc)
   4871 {
   4872     PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV =
   4873         __glGetProcAddress("glVertexAttrib2fvNV");
   4874     VertexAttrib2fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4875 }
   4876 
   4877 void
   4878 __glXDisp_VertexAttrib2svNV(GLbyte * pc)
   4879 {
   4880     PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV =
   4881         __glGetProcAddress("glVertexAttrib2svNV");
   4882     VertexAttrib2svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4883 }
   4884 
   4885 void
   4886 __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
   4887 {
   4888     PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
   4889         __glGetProcAddress("glVertexAttrib3dvNV");
   4890 #ifdef __GLX_ALIGN64
   4891     if ((unsigned long) (pc) & 7) {
   4892         (void) memmove(pc - 4, pc, 28);
   4893         pc -= 4;
   4894     }
   4895 #endif
   4896 
   4897     VertexAttrib3dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4898 }
   4899 
   4900 void
   4901 __glXDisp_VertexAttrib3fvNV(GLbyte * pc)
   4902 {
   4903     PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV =
   4904         __glGetProcAddress("glVertexAttrib3fvNV");
   4905     VertexAttrib3fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4906 }
   4907 
   4908 void
   4909 __glXDisp_VertexAttrib3svNV(GLbyte * pc)
   4910 {
   4911     PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV =
   4912         __glGetProcAddress("glVertexAttrib3svNV");
   4913     VertexAttrib3svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4914 }
   4915 
   4916 void
   4917 __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
   4918 {
   4919     PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
   4920         __glGetProcAddress("glVertexAttrib4dvNV");
   4921 #ifdef __GLX_ALIGN64
   4922     if ((unsigned long) (pc) & 7) {
   4923         (void) memmove(pc - 4, pc, 36);
   4924         pc -= 4;
   4925     }
   4926 #endif
   4927 
   4928     VertexAttrib4dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
   4929 }
   4930 
   4931 void
   4932 __glXDisp_VertexAttrib4fvNV(GLbyte * pc)
   4933 {
   4934     PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV =
   4935         __glGetProcAddress("glVertexAttrib4fvNV");
   4936     VertexAttrib4fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
   4937 }
   4938 
   4939 void
   4940 __glXDisp_VertexAttrib4svNV(GLbyte * pc)
   4941 {
   4942     PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV =
   4943         __glGetProcAddress("glVertexAttrib4svNV");
   4944     VertexAttrib4svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
   4945 }
   4946 
   4947 void
   4948 __glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
   4949 {
   4950     PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV =
   4951         __glGetProcAddress("glVertexAttrib4ubvNV");
   4952     VertexAttrib4ubvNV(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
   4953 }
   4954 
   4955 void
   4956 __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
   4957 {
   4958     PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV =
   4959         __glGetProcAddress("glVertexAttribs1dvNV");
   4960     const GLsizei n = *(GLsizei *) (pc + 4);
   4961 
   4962 #ifdef __GLX_ALIGN64
   4963     const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
   4964 
   4965     if ((unsigned long) (pc) & 7) {
   4966         (void) memmove(pc - 4, pc, cmdlen);
   4967         pc -= 4;
   4968     }
   4969 #endif
   4970 
   4971     VertexAttribs1dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
   4972 }
   4973 
   4974 void
   4975 __glXDisp_VertexAttribs1fvNV(GLbyte * pc)
   4976 {
   4977     PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV =
   4978         __glGetProcAddress("glVertexAttribs1fvNV");
   4979     const GLsizei n = *(GLsizei *) (pc + 4);
   4980 
   4981     VertexAttribs1fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
   4982 }
   4983 
   4984 void
   4985 __glXDisp_VertexAttribs1svNV(GLbyte * pc)
   4986 {
   4987     PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV =
   4988         __glGetProcAddress("glVertexAttribs1svNV");
   4989     const GLsizei n = *(GLsizei *) (pc + 4);
   4990 
   4991     VertexAttribs1svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
   4992 }
   4993 
   4994 void
   4995 __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
   4996 {
   4997     PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV =
   4998         __glGetProcAddress("glVertexAttribs2dvNV");
   4999     const GLsizei n = *(GLsizei *) (pc + 4);
   5000 
   5001 #ifdef __GLX_ALIGN64
   5002     const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
   5003 
   5004     if ((unsigned long) (pc) & 7) {
   5005         (void) memmove(pc - 4, pc, cmdlen);
   5006         pc -= 4;
   5007     }
   5008 #endif
   5009 
   5010     VertexAttribs2dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
   5011 }
   5012 
   5013 void
   5014 __glXDisp_VertexAttribs2fvNV(GLbyte * pc)
   5015 {
   5016     PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV =
   5017         __glGetProcAddress("glVertexAttribs2fvNV");
   5018     const GLsizei n = *(GLsizei *) (pc + 4);
   5019 
   5020     VertexAttribs2fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
   5021 }
   5022 
   5023 void
   5024 __glXDisp_VertexAttribs2svNV(GLbyte * pc)
   5025 {
   5026     PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV =
   5027         __glGetProcAddress("glVertexAttribs2svNV");
   5028     const GLsizei n = *(GLsizei *) (pc + 4);
   5029 
   5030     VertexAttribs2svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
   5031 }
   5032 
   5033 void
   5034 __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
   5035 {
   5036     PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV =
   5037         __glGetProcAddress("glVertexAttribs3dvNV");
   5038     const GLsizei n = *(GLsizei *) (pc + 4);
   5039 
   5040 #ifdef __GLX_ALIGN64
   5041     const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
   5042 
   5043     if ((unsigned long) (pc) & 7) {
   5044         (void) memmove(pc - 4, pc, cmdlen);
   5045         pc -= 4;
   5046     }
   5047 #endif
   5048 
   5049     VertexAttribs3dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
   5050 }
   5051 
   5052 void
   5053 __glXDisp_VertexAttribs3fvNV(GLbyte * pc)
   5054 {
   5055     PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV =
   5056         __glGetProcAddress("glVertexAttribs3fvNV");
   5057     const GLsizei n = *(GLsizei *) (pc + 4);
   5058 
   5059     VertexAttribs3fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
   5060 }
   5061 
   5062 void
   5063 __glXDisp_VertexAttribs3svNV(GLbyte * pc)
   5064 {
   5065     PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV =
   5066         __glGetProcAddress("glVertexAttribs3svNV");
   5067     const GLsizei n = *(GLsizei *) (pc + 4);
   5068 
   5069     VertexAttribs3svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
   5070 }
   5071 
   5072 void
   5073 __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
   5074 {
   5075     PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV =
   5076         __glGetProcAddress("glVertexAttribs4dvNV");
   5077     const GLsizei n = *(GLsizei *) (pc + 4);
   5078 
   5079 #ifdef __GLX_ALIGN64
   5080     const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
   5081 
   5082     if ((unsigned long) (pc) & 7) {
   5083         (void) memmove(pc - 4, pc, cmdlen);
   5084         pc -= 4;
   5085     }
   5086 #endif
   5087 
   5088     VertexAttribs4dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
   5089 }
   5090 
   5091 void
   5092 __glXDisp_VertexAttribs4fvNV(GLbyte * pc)
   5093 {
   5094     PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV =
   5095         __glGetProcAddress("glVertexAttribs4fvNV");
   5096     const GLsizei n = *(GLsizei *) (pc + 4);
   5097 
   5098     VertexAttribs4fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
   5099 }
   5100 
   5101 void
   5102 __glXDisp_VertexAttribs4svNV(GLbyte * pc)
   5103 {
   5104     PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV =
   5105         __glGetProcAddress("glVertexAttribs4svNV");
   5106     const GLsizei n = *(GLsizei *) (pc + 4);
   5107 
   5108     VertexAttribs4svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
   5109 }
   5110 
   5111 void
   5112 __glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
   5113 {
   5114     PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV =
   5115         __glGetProcAddress("glVertexAttribs4ubvNV");
   5116     const GLsizei n = *(GLsizei *) (pc + 4);
   5117 
   5118     VertexAttribs4ubvNV(*(GLuint *) (pc + 0), n, (const GLubyte *) (pc + 8));
   5119 }
   5120 
   5121 void
   5122 __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
   5123 {
   5124     PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
   5125         __glGetProcAddress("glActiveStencilFaceEXT");
   5126     ActiveStencilFaceEXT(*(GLenum *) (pc + 0));
   5127 }
	xserver xserver with xephyr scale patch
	git clone https://git.neptards.moe/u3shit/xserver.git
	Log \| Files \| Refs \| README \| LICENSE