src/glx/x11/single2.c

   1 /* -*- mode: c; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 3; coding: utf-8-unix -*- */
   2 /*
   3  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   4  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice including the dates of first publication and
  14  * either this permission notice or a reference to
  15  * http://oss.sgi.com/projects/FreeB/
  16  * shall be included in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  23  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  *
  26  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  27  * shall not be used in advertising or otherwise to promote the sale, use or
  28  * other dealings in this Software without prior written authorization from
  29  * Silicon Graphics, Inc.
  30  */
  31
  32 #include <stdio.h>
  33 #include <assert.h>
  34 #include "glxclient.h"
  35 #include "packsingle.h"
  36 #include "glxextensions.h"
  37 #include "indirect.h"
  38 #include "indirect_vertex_array.h"
  39 #include "dispatch.h"
  40 #include "glapi.h"
  41
  42 /* Used for GL_ARB_transpose_matrix */
  43 static void
  44 TransposeMatrixf(GLfloat m[16])
  45 {
  46    int i, j;
  47    for (i = 0; i < 4; i++) {
  48       for (j = 0; j < i; j++) {
  49          GLfloat tmp = m[i * 4 + j];
  50          m[i * 4 + j] = m[j * 4 + i];
  51          m[j * 4 + i] = tmp;
  52       }
  53    }
  54 }
  55
  56 /* Used for GL_ARB_transpose_matrix */
  57 static void
  58 TransposeMatrixb(GLboolean m[16])
  59 {
  60    int i, j;
  61    for (i = 0; i < 4; i++) {
  62       for (j = 0; j < i; j++) {
  63          GLboolean tmp = m[i * 4 + j];
  64          m[i * 4 + j] = m[j * 4 + i];
  65          m[j * 4 + i] = tmp;
  66       }
  67    }
  68 }
  69
  70 /* Used for GL_ARB_transpose_matrix */
  71 static void
  72 TransposeMatrixd(GLdouble m[16])
  73 {
  74    int i, j;
  75    for (i = 0; i < 4; i++) {
  76       for (j = 0; j < i; j++) {
  77          GLdouble tmp = m[i * 4 + j];
  78          m[i * 4 + j] = m[j * 4 + i];
  79          m[j * 4 + i] = tmp;
  80       }
  81    }
  82 }
  83
  84 /* Used for GL_ARB_transpose_matrix */
  85 static void
  86 TransposeMatrixi(GLint m[16])
  87 {
  88    int i, j;
  89    for (i = 0; i < 4; i++) {
  90       for (j = 0; j < i; j++) {
  91          GLint tmp = m[i * 4 + j];
  92          m[i * 4 + j] = m[j * 4 + i];
  93          m[j * 4 + i] = tmp;
  94       }
  95    }
  96 }
  97
  98
  99 /**
 100  * Remap a transpose-matrix enum to a non-transpose-matrix enum.  Enums
 101  * that are not transpose-matrix enums are unaffected.
 102  */
 103 static GLenum
 104 RemapTransposeEnum(GLenum e)
 105 {
 106    switch (e) {
 107    case GL_TRANSPOSE_MODELVIEW_MATRIX:
 108    case GL_TRANSPOSE_PROJECTION_MATRIX:
 109    case GL_TRANSPOSE_TEXTURE_MATRIX:
 110       return e - (GL_TRANSPOSE_MODELVIEW_MATRIX - GL_MODELVIEW_MATRIX);
 111    case GL_TRANSPOSE_COLOR_MATRIX:
 112       return GL_COLOR_MATRIX;
 113    default:
 114       return e;
 115    };
 116 }
 117
 118
 119 GLenum
 120 __indirect_glGetError(void)
 121 {
 122    __GLX_SINGLE_DECLARE_VARIABLES();
 123    GLuint retval = GL_NO_ERROR;
 124    xGLXGetErrorReply reply;
 125
 126    if (gc->error) {
 127       /* Use internal error first */
 128       retval = gc->error;
 129       gc->error = GL_NO_ERROR;
 130       return retval;
 131    }
 132
 133    __GLX_SINGLE_LOAD_VARIABLES();
 134    __GLX_SINGLE_BEGIN(X_GLsop_GetError, 0);
 135    __GLX_SINGLE_READ_XREPLY();
 136    retval = reply.error;
 137    __GLX_SINGLE_END();
 138
 139    return retval;
 140 }
 141
 142
 143 /**
 144  * Get the selected attribute from the client state.
 145  *
 146  * \returns
 147  * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
 148  */
 149 static GLboolean
 150 get_client_data(__GLXcontext * gc, GLenum cap, GLintptr * data)
 151 {
 152    GLboolean retval = GL_TRUE;
 153    __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
 154    const GLint tex_unit = __glXGetActiveTextureUnit(state);
 155
 156
 157    switch (cap) {
 158    case GL_VERTEX_ARRAY:
 159    case GL_NORMAL_ARRAY:
 160    case GL_COLOR_ARRAY:
 161    case GL_INDEX_ARRAY:
 162    case GL_EDGE_FLAG_ARRAY:
 163    case GL_SECONDARY_COLOR_ARRAY:
 164    case GL_FOG_COORD_ARRAY:
 165       retval = __glXGetArrayEnable(state, cap, 0, data);
 166       break;
 167
 168    case GL_VERTEX_ARRAY_SIZE:
 169       retval = __glXGetArraySize(state, GL_VERTEX_ARRAY, 0, data);
 170       break;
 171    case GL_COLOR_ARRAY_SIZE:
 172       retval = __glXGetArraySize(state, GL_COLOR_ARRAY, 0, data);
 173       break;
 174    case GL_SECONDARY_COLOR_ARRAY_SIZE:
 175       retval = __glXGetArraySize(state, GL_SECONDARY_COLOR_ARRAY, 0, data);
 176       break;
 177
 178    case GL_VERTEX_ARRAY_TYPE:
 179       retval = __glXGetArrayType(state, GL_VERTEX_ARRAY, 0, data);
 180       break;
 181    case GL_NORMAL_ARRAY_TYPE:
 182       retval = __glXGetArrayType(state, GL_NORMAL_ARRAY, 0, data);
 183       break;
 184    case GL_INDEX_ARRAY_TYPE:
 185       retval = __glXGetArrayType(state, GL_INDEX_ARRAY, 0, data);
 186       break;
 187    case GL_COLOR_ARRAY_TYPE:
 188       retval = __glXGetArrayType(state, GL_COLOR_ARRAY, 0, data);
 189       break;
 190    case GL_SECONDARY_COLOR_ARRAY_TYPE:
 191       retval = __glXGetArrayType(state, GL_SECONDARY_COLOR_ARRAY, 0, data);
 192       break;
 193    case GL_FOG_COORD_ARRAY_TYPE:
 194       retval = __glXGetArrayType(state, GL_FOG_COORD_ARRAY, 0, data);
 195       break;
 196
 197    case GL_VERTEX_ARRAY_STRIDE:
 198       retval = __glXGetArrayStride(state, GL_VERTEX_ARRAY, 0, data);
 199       break;
 200    case GL_NORMAL_ARRAY_STRIDE:
 201       retval = __glXGetArrayStride(state, GL_NORMAL_ARRAY, 0, data);
 202       break;
 203    case GL_INDEX_ARRAY_STRIDE:
 204       retval = __glXGetArrayStride(state, GL_INDEX_ARRAY, 0, data);
 205       break;
 206    case GL_EDGE_FLAG_ARRAY_STRIDE:
 207       retval = __glXGetArrayStride(state, GL_EDGE_FLAG_ARRAY, 0, data);
 208       break;
 209    case GL_COLOR_ARRAY_STRIDE:
 210       retval = __glXGetArrayStride(state, GL_COLOR_ARRAY, 0, data);
 211       break;
 212    case GL_SECONDARY_COLOR_ARRAY_STRIDE:
 213       retval = __glXGetArrayStride(state, GL_SECONDARY_COLOR_ARRAY, 0, data);
 214       break;
 215    case GL_FOG_COORD_ARRAY_STRIDE:
 216       retval = __glXGetArrayStride(state, GL_FOG_COORD_ARRAY, 0, data);
 217       break;
 218
 219    case GL_TEXTURE_COORD_ARRAY:
 220       retval =
 221          __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
 222       break;
 223    case GL_TEXTURE_COORD_ARRAY_SIZE:
 224       retval =
 225          __glXGetArraySize(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
 226       break;
 227    case GL_TEXTURE_COORD_ARRAY_TYPE:
 228       retval =
 229          __glXGetArrayType(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
 230       break;
 231    case GL_TEXTURE_COORD_ARRAY_STRIDE:
 232       retval =
 233          __glXGetArrayStride(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
 234       break;
 235
 236    case GL_MAX_ELEMENTS_VERTICES:
 237    case GL_MAX_ELEMENTS_INDICES:
 238       retval = GL_TRUE;
 239       *data = ~0UL;
 240       break;
 241
 242
 243    case GL_PACK_ROW_LENGTH:
 244       *data = (GLintptr) state->storePack.rowLength;
 245       break;
 246    case GL_PACK_IMAGE_HEIGHT:
 247       *data = (GLintptr) state->storePack.imageHeight;
 248       break;
 249    case GL_PACK_SKIP_ROWS:
 250       *data = (GLintptr) state->storePack.skipRows;
 251       break;
 252    case GL_PACK_SKIP_PIXELS:
 253       *data = (GLintptr) state->storePack.skipPixels;
 254       break;
 255    case GL_PACK_SKIP_IMAGES:
 256       *data = (GLintptr) state->storePack.skipImages;
 257       break;
 258    case GL_PACK_ALIGNMENT:
 259       *data = (GLintptr) state->storePack.alignment;
 260       break;
 261    case GL_PACK_SWAP_BYTES:
 262       *data = (GLintptr) state->storePack.swapEndian;
 263       break;
 264    case GL_PACK_LSB_FIRST:
 265       *data = (GLintptr) state->storePack.lsbFirst;
 266       break;
 267    case GL_UNPACK_ROW_LENGTH:
 268       *data = (GLintptr) state->storeUnpack.rowLength;
 269       break;
 270    case GL_UNPACK_IMAGE_HEIGHT:
 271       *data = (GLintptr) state->storeUnpack.imageHeight;
 272       break;
 273    case GL_UNPACK_SKIP_ROWS:
 274       *data = (GLintptr) state->storeUnpack.skipRows;
 275       break;
 276    case GL_UNPACK_SKIP_PIXELS:
 277       *data = (GLintptr) state->storeUnpack.skipPixels;
 278       break;
 279    case GL_UNPACK_SKIP_IMAGES:
 280       *data = (GLintptr) state->storeUnpack.skipImages;
 281       break;
 282    case GL_UNPACK_ALIGNMENT:
 283       *data = (GLintptr) state->storeUnpack.alignment;
 284       break;
 285    case GL_UNPACK_SWAP_BYTES:
 286       *data = (GLintptr) state->storeUnpack.swapEndian;
 287       break;
 288    case GL_UNPACK_LSB_FIRST:
 289       *data = (GLintptr) state->storeUnpack.lsbFirst;
 290       break;
 291    case GL_CLIENT_ATTRIB_STACK_DEPTH:
 292       *data = (GLintptr) (gc->attributes.stackPointer - gc->attributes.stack);
 293       break;
 294    case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 295       *data = (GLintptr) __GL_CLIENT_ATTRIB_STACK_DEPTH;
 296       break;
 297    case GL_CLIENT_ACTIVE_TEXTURE:
 298       *data = (GLintptr) (tex_unit + GL_TEXTURE0);
 299       break;
 300
 301    default:
 302       retval = GL_FALSE;
 303       break;
 304    }
 305
 306
 307    return retval;
 308 }
 309
 310
 311 void
 312 __indirect_glGetBooleanv(GLenum val, GLboolean * b)
 313 {
 314    const GLenum origVal = val;
 315    __GLX_SINGLE_DECLARE_VARIABLES();
 316    xGLXSingleReply reply;
 317
 318    val = RemapTransposeEnum(val);
 319
 320    __GLX_SINGLE_LOAD_VARIABLES();
 321    __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv, 4);
 322    __GLX_SINGLE_PUT_LONG(0, val);
 323    __GLX_SINGLE_READ_XREPLY();
 324    __GLX_SINGLE_GET_SIZE(compsize);
 325
 326    if (compsize == 0) {
 327       /*
 328        ** Error occured; don't modify user's buffer.
 329        */
 330    }
 331    else {
 332       GLintptr data;
 333
 334       /*
 335        ** We still needed to send the request to the server in order to
 336        ** find out whether it was legal to make a query (it's illegal,
 337        ** for example, to call a query between glBegin() and glEnd()).
 338        */
 339
 340       if (get_client_data(gc, val, &data)) {
 341          *b = (GLboolean) data;
 342       }
 343       else {
 344          /*
 345           ** Not a local value, so use what we got from the server.
 346           */
 347          if (compsize == 1) {
 348             __GLX_SINGLE_GET_CHAR(b);
 349          }
 350          else {
 351             __GLX_SINGLE_GET_CHAR_ARRAY(b, compsize);
 352             if (val != origVal) {
 353                /* matrix transpose */
 354                TransposeMatrixb(b);
 355             }
 356          }
 357       }
 358    }
 359    __GLX_SINGLE_END();
 360 }
 361
 362 void
 363 __indirect_glGetDoublev(GLenum val, GLdouble * d)
 364 {
 365    const GLenum origVal = val;
 366    __GLX_SINGLE_DECLARE_VARIABLES();
 367    xGLXSingleReply reply;
 368
 369    val = RemapTransposeEnum(val);
 370
 371    __GLX_SINGLE_LOAD_VARIABLES();
 372    __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev, 4);
 373    __GLX_SINGLE_PUT_LONG(0, val);
 374    __GLX_SINGLE_READ_XREPLY();
 375    __GLX_SINGLE_GET_SIZE(compsize);
 376
 377    if (compsize == 0) {
 378       /*
 379        ** Error occured; don't modify user's buffer.
 380        */
 381    }
 382    else {
 383       GLintptr data;
 384
 385       /*
 386        ** We still needed to send the request to the server in order to
 387        ** find out whether it was legal to make a query (it's illegal,
 388        ** for example, to call a query between glBegin() and glEnd()).
 389        */
 390
 391       if (get_client_data(gc, val, &data)) {
 392          *d = (GLdouble) data;
 393       }
 394       else {
 395          /*
 396           ** Not a local value, so use what we got from the server.
 397           */
 398          if (compsize == 1) {
 399             __GLX_SINGLE_GET_DOUBLE(d);
 400          }
 401          else {
 402             __GLX_SINGLE_GET_DOUBLE_ARRAY(d, compsize);
 403             if (val != origVal) {
 404                /* matrix transpose */
 405                TransposeMatrixd(d);
 406             }
 407          }
 408       }
 409    }
 410    __GLX_SINGLE_END();
 411 }
 412
 413 void
 414 __indirect_glGetFloatv(GLenum val, GLfloat * f)
 415 {
 416    const GLenum origVal = val;
 417    __GLX_SINGLE_DECLARE_VARIABLES();
 418    xGLXSingleReply reply;
 419
 420    val = RemapTransposeEnum(val);
 421
 422    __GLX_SINGLE_LOAD_VARIABLES();
 423    __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv, 4);
 424    __GLX_SINGLE_PUT_LONG(0, val);
 425    __GLX_SINGLE_READ_XREPLY();
 426    __GLX_SINGLE_GET_SIZE(compsize);
 427
 428    if (compsize == 0) {
 429       /*
 430        ** Error occured; don't modify user's buffer.
 431        */
 432    }
 433    else {
 434       GLintptr data;
 435
 436       /*
 437        ** We still needed to send the request to the server in order to
 438        ** find out whether it was legal to make a query (it's illegal,
 439        ** for example, to call a query between glBegin() and glEnd()).
 440        */
 441
 442       if (get_client_data(gc, val, &data)) {
 443          *f = (GLfloat) data;
 444       }
 445       else {
 446          /*
 447           ** Not a local value, so use what we got from the server.
 448           */
 449          if (compsize == 1) {
 450             __GLX_SINGLE_GET_FLOAT(f);
 451          }
 452          else {
 453             __GLX_SINGLE_GET_FLOAT_ARRAY(f, compsize);
 454             if (val != origVal) {
 455                /* matrix transpose */
 456                TransposeMatrixf(f);
 457             }
 458          }
 459       }
 460    }
 461    __GLX_SINGLE_END();
 462 }
 463
 464 void
 465 __indirect_glGetIntegerv(GLenum val, GLint * i)
 466 {
 467    const GLenum origVal = val;
 468    __GLX_SINGLE_DECLARE_VARIABLES();
 469    xGLXSingleReply reply;
 470
 471    val = RemapTransposeEnum(val);
 472
 473    __GLX_SINGLE_LOAD_VARIABLES();
 474    __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv, 4);
 475    __GLX_SINGLE_PUT_LONG(0, val);
 476    __GLX_SINGLE_READ_XREPLY();
 477    __GLX_SINGLE_GET_SIZE(compsize);
 478
 479    if (compsize == 0) {
 480       /*
 481        ** Error occured; don't modify user's buffer.
 482        */
 483    }
 484    else {
 485       GLintptr data;
 486
 487       /*
 488        ** We still needed to send the request to the server in order to
 489        ** find out whether it was legal to make a query (it's illegal,
 490        ** for example, to call a query between glBegin() and glEnd()).
 491        */
 492
 493       if (get_client_data(gc, val, &data)) {
 494          *i = (GLint) data;
 495       }
 496       else {
 497          /*
 498           ** Not a local value, so use what we got from the server.
 499           */
 500          if (compsize == 1) {
 501             __GLX_SINGLE_GET_LONG(i);
 502          }
 503          else {
 504             __GLX_SINGLE_GET_LONG_ARRAY(i, compsize);
 505             if (val != origVal) {
 506                /* matrix transpose */
 507                TransposeMatrixi(i);
 508             }
 509          }
 510       }
 511    }
 512    __GLX_SINGLE_END();
 513 }
 514
 515 /*
 516 ** Send all pending commands to server.
 517 */
 518 void
 519 __indirect_glFlush(void)
 520 {
 521    __GLX_SINGLE_DECLARE_VARIABLES();
 522
 523    if (!dpy)
 524       return;
 525
 526    __GLX_SINGLE_LOAD_VARIABLES();
 527    __GLX_SINGLE_BEGIN(X_GLsop_Flush, 0);
 528    __GLX_SINGLE_END();
 529
 530    /* And finally flush the X protocol data */
 531    XFlush(dpy);
 532 }
 533
 534 void
 535 __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
 536 {
 537    __GLX_SINGLE_DECLARE_VARIABLES();
 538
 539    if (!dpy)
 540       return;
 541
 542    __GLX_SINGLE_LOAD_VARIABLES();
 543    __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer, 8);
 544    __GLX_SINGLE_PUT_LONG(0, size);
 545    __GLX_SINGLE_PUT_LONG(4, type);
 546    __GLX_SINGLE_END();
 547
 548    gc->feedbackBuf = buffer;
 549 }
 550
 551 void
 552 __indirect_glSelectBuffer(GLsizei numnames, GLuint * buffer)
 553 {
 554    __GLX_SINGLE_DECLARE_VARIABLES();
 555
 556    if (!dpy)
 557       return;
 558
 559    __GLX_SINGLE_LOAD_VARIABLES();
 560    __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer, 4);
 561    __GLX_SINGLE_PUT_LONG(0, numnames);
 562    __GLX_SINGLE_END();
 563
 564    gc->selectBuf = buffer;
 565 }
 566
 567 GLint
 568 __indirect_glRenderMode(GLenum mode)
 569 {
 570    __GLX_SINGLE_DECLARE_VARIABLES();
 571    GLint retval = 0;
 572    xGLXRenderModeReply reply;
 573
 574    if (!dpy)
 575       return -1;
 576
 577    __GLX_SINGLE_LOAD_VARIABLES();
 578    __GLX_SINGLE_BEGIN(X_GLsop_RenderMode, 4);
 579    __GLX_SINGLE_PUT_LONG(0, mode);
 580    __GLX_SINGLE_READ_XREPLY();
 581    __GLX_SINGLE_GET_RETVAL(retval, GLint);
 582
 583    if (reply.newMode != mode) {
 584       /*
 585        ** Switch to new mode did not take effect, therefore an error
 586        ** occured.  When an error happens the server won't send us any
 587        ** other data.
 588        */
 589    }
 590    else {
 591       /* Read the feedback or selection data */
 592       if (gc->renderMode == GL_FEEDBACK) {
 593          __GLX_SINGLE_GET_SIZE(compsize);
 594          __GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize);
 595       }
 596       else if (gc->renderMode == GL_SELECT) {
 597          __GLX_SINGLE_GET_SIZE(compsize);
 598          __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
 599       }
 600       gc->renderMode = mode;
 601    }
 602    __GLX_SINGLE_END();
 603
 604    return retval;
 605 }
 606
 607 void
 608 __indirect_glFinish(void)
 609 {
 610    __GLX_SINGLE_DECLARE_VARIABLES();
 611    xGLXSingleReply reply;
 612
 613    __GLX_SINGLE_LOAD_VARIABLES();
 614    __GLX_SINGLE_BEGIN(X_GLsop_Finish, 0);
 615    __GLX_SINGLE_READ_XREPLY();
 616    __GLX_SINGLE_END();
 617 }
 618
 619
 620 /**
 621  * Extract the major and minor version numbers from a version string.
 622  */
 623 static void
 624 version_from_string(const char *ver, int *major_version, int *minor_version)
 625 {
 626    const char *end;
 627    long major;
 628    long minor;
 629
 630    major = strtol(ver, (char **) &end, 10);
 631    minor = strtol(end + 1, NULL, 10);
 632    *major_version = major;
 633    *minor_version = minor;
 634 }
 635
 636
 637 const GLubyte *
 638 __indirect_glGetString(GLenum name)
 639 {
 640    __GLXcontext *gc = __glXGetCurrentContext();
 641    Display *dpy = gc->currentDpy;
 642    GLubyte *s = NULL;
 643
 644    if (!dpy)
 645       return 0;
 646
 647    /*
 648     ** Return the cached copy if the string has already been fetched
 649     */
 650    switch (name) {
 651    case GL_VENDOR:
 652       if (gc->vendor)
 653          return gc->vendor;
 654       break;
 655    case GL_RENDERER:
 656       if (gc->renderer)
 657          return gc->renderer;
 658       break;
 659    case GL_VERSION:
 660       if (gc->version)
 661          return gc->version;
 662       break;
 663    case GL_EXTENSIONS:
 664       if (gc->extensions)
 665          return gc->extensions;
 666       break;
 667    default:
 668       __glXSetError(gc, GL_INVALID_ENUM);
 669       return 0;
 670    }
 671
 672    /*
 673     ** Get requested string from server
 674     */
 675
 676    (void) __glXFlushRenderBuffer(gc, gc->pc);
 677    s = (GLubyte *) __glXGetStringFromServer(dpy, gc->majorOpcode,
 678                                             X_GLsop_GetString,
 679                                             gc->currentContextTag, name);
 680    if (!s) {
 681       /* Throw data on the floor */
 682       __glXSetError(gc, GL_OUT_OF_MEMORY);
 683    }
 684    else {
 685       /*
 686        ** Update local cache
 687        */
 688       switch (name) {
 689       case GL_VENDOR:
 690          gc->vendor = s;
 691          break;
 692
 693       case GL_RENDERER:
 694          gc->renderer = s;
 695          break;
 696
 697       case GL_VERSION:{
 698             int client_major;
 699             int client_minor;
 700
 701             version_from_string((char *) s,
 702                                 &gc->server_major, &gc->server_minor);
 703             __glXGetGLVersion(&client_major, &client_minor);
 704
 705             if ((gc->server_major < client_major)
 706                 || ((gc->server_major == client_major)
 707                     && (gc->server_minor <= client_minor))) {
 708                gc->version = s;
 709             }
 710             else {
 711                /* Allow 7 bytes for the client-side GL version.  This allows
 712                 * for upto version 999.999.  I'm not holding my breath for
 713                 * that one!  The extra 4 is for the ' ()\0' that will be
 714                 * added.
 715                 */
 716                const size_t size = 7 + strlen((char *) s) + 4;
 717
 718                gc->version = Xmalloc(size);
 719                if (gc->version == NULL) {
 720                   /* If we couldn't allocate memory for the new string,
 721                    * make a best-effort and just copy the client-side version
 722                    * to the string and use that.  It probably doesn't
 723                    * matter what is done here.  If there not memory available
 724                    * for a short string, the system is probably going to die
 725                    * soon anyway.
 726                    */
 727                   snprintf((char *) s, strlen((char *) s) + 1, "%u.%u",
 728                            client_major, client_minor);
 729                   gc->version = s;
 730                }
 731                else {
 732                   snprintf((char *) gc->version, size, "%u.%u (%s)",
 733                            client_major, client_minor, s);
 734                   Xfree(s);
 735                   s = gc->version;
 736                }
 737             }
 738             break;
 739          }
 740
 741       case GL_EXTENSIONS:{
 742             int major = 1;
 743             int minor = 0;
 744
 745             /* This code is currently disabled.  I was reminded that some
 746              * vendors intentionally exclude some extensions from their
 747              * extension string that are part of the core version they
 748              * advertise.  In particular, on Nvidia drivers this means that
 749              * the functionality is supported by the driver, but is not
 750              * hardware accelerated.  For example, a TNT will show core
 751              * version 1.5, but most of the post-1.2 functionality is a
 752              * software fallback.
 753              *
 754              * I don't want to break applications that rely on this odd
 755              * behavior.  At the same time, the code is written and tested,
 756              * so I didn't want to throw it away.  Therefore, the code is here
 757              * but disabled.  In the future, we may wish to and an environment
 758              * variable to enable it.
 759              */
 760
 761 #if 0
 762             /* Call glGetString just to make sure that gc->server_major and
 763              * gc->server_minor are set.  This version may be higher than we
 764              * can completely support, but it may imply support for some
 765              * extensions that we can support.
 766              *
 767              * For example, at the time of this writing, the client-side
 768              * library only supports upto core GL version 1.2.  However, cubic
 769              * textures, multitexture, multisampling, and some other 1.3
 770              * features are supported.  If the server reports back version
 771              * 1.3, but does not report all of those extensions, we will
 772              * enable them.
 773              */
 774             (void *) glGetString(GL_VERSION);
 775             major = gc->server_major, minor = gc->server_minor;
 776 #endif
 777
 778             __glXCalculateUsableGLExtensions(gc, (char *) s, major, minor);
 779             XFree(s);
 780             s = gc->extensions;
 781             break;
 782          }
 783       }
 784    }
 785    return s;
 786 }
 787
 788 GLboolean
 789 __indirect_glIsEnabled(GLenum cap)
 790 {
 791    __GLX_SINGLE_DECLARE_VARIABLES();
 792    __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
 793    xGLXSingleReply reply;
 794    GLboolean retval = 0;
 795    GLintptr enable;
 796
 797    if (!dpy)
 798       return 0;
 799
 800    switch (cap) {
 801    case GL_VERTEX_ARRAY:
 802    case GL_NORMAL_ARRAY:
 803    case GL_COLOR_ARRAY:
 804    case GL_INDEX_ARRAY:
 805    case GL_EDGE_FLAG_ARRAY:
 806    case GL_SECONDARY_COLOR_ARRAY:
 807    case GL_FOG_COORD_ARRAY:
 808       retval = __glXGetArrayEnable(state, cap, 0, &enable);
 809       assert(retval);
 810       return (GLboolean) enable;
 811       break;
 812    case GL_TEXTURE_COORD_ARRAY:
 813       retval = __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY,
 814                                    __glXGetActiveTextureUnit(state), &enable);
 815       assert(retval);
 816       return (GLboolean) enable;
 817       break;
 818    }
 819
 820    __GLX_SINGLE_LOAD_VARIABLES();
 821    __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled, 4);
 822    __GLX_SINGLE_PUT_LONG(0, cap);
 823    __GLX_SINGLE_READ_XREPLY();
 824    __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
 825    __GLX_SINGLE_END();
 826    return retval;
 827 }
 828
 829 void
 830 __indirect_glGetPointerv(GLenum pname, void **params)
 831 {
 832    __GLXcontext *gc = __glXGetCurrentContext();
 833    __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
 834    Display *dpy = gc->currentDpy;
 835
 836    if (!dpy)
 837       return;
 838
 839    switch (pname) {
 840    case GL_VERTEX_ARRAY_POINTER:
 841    case GL_NORMAL_ARRAY_POINTER:
 842    case GL_COLOR_ARRAY_POINTER:
 843    case GL_INDEX_ARRAY_POINTER:
 844    case GL_EDGE_FLAG_ARRAY_POINTER:
 845       __glXGetArrayPointer(state, pname - GL_VERTEX_ARRAY_POINTER
 846                            + GL_VERTEX_ARRAY, 0, params);
 847       return;
 848    case GL_TEXTURE_COORD_ARRAY_POINTER:
 849       __glXGetArrayPointer(state, GL_TEXTURE_COORD_ARRAY,
 850                            __glXGetActiveTextureUnit(state), params);
 851       return;
 852    case GL_SECONDARY_COLOR_ARRAY_POINTER:
 853    case GL_FOG_COORD_ARRAY_POINTER:
 854       __glXGetArrayPointer(state, pname - GL_FOG_COORD_ARRAY_POINTER
 855                            + GL_FOG_COORD_ARRAY, 0, params);
 856       return;
 857    case GL_FEEDBACK_BUFFER_POINTER:
 858       *params = (void *) gc->feedbackBuf;
 859       return;
 860    case GL_SELECTION_BUFFER_POINTER:
 861       *params = (void *) gc->selectBuf;
 862       return;
 863    default:
 864       __glXSetError(gc, GL_INVALID_ENUM);
 865       return;
 866    }
 867 }
 868
 869
 870
 871 /**
 872  * This was previously auto-generated, but we need to special-case
 873  * how we handle writing into the 'residences' buffer when n%4!=0.
 874  */
 875 #define X_GLsop_AreTexturesResident 143
 876 GLboolean
 877 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures,
 878                                  GLboolean * residences)
 879 {
 880     __GLXcontext *const gc = __glXGetCurrentContext();
 881     Display *const dpy = gc->currentDpy;
 882     GLboolean retval = (GLboolean) 0;
 883     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
 884     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
 885 #ifdef USE_XCB
 886         xcb_connection_t *c = XGetXCBConnection(dpy);
 887         (void) __glXFlushRenderBuffer(gc, gc->pc);
 888         xcb_glx_are_textures_resident_reply_t *reply =
 889             xcb_glx_are_textures_resident_reply(c,
 890                                                 xcb_glx_are_textures_resident
 891                                                 (c, gc->currentContextTag, n,
 892                                                  textures), NULL);
 893         (void) memcpy(residences, xcb_glx_are_textures_resident_data(reply),
 894                       xcb_glx_are_textures_resident_data_length(reply) *
 895                       sizeof(GLboolean));
 896         retval = reply->ret_val;
 897         free(reply);
 898 #else
 899         GLubyte const *pc =
 900             __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
 901         (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
 902         (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
 903         if (n & 3) {
 904            /* n is not a multiple of four.
 905             * When reply_is_always_array is TRUE, __glXReadReply() will
 906             * put a multiple of four bytes into the dest buffer.  If the
 907             * caller's buffer is not a multiple of four in size, we'll write
 908             * out of bounds.  So use a temporary buffer that's a few bytes
 909             * larger.
 910             */
 911            GLboolean *res4 = malloc((n + 3) & ~3);
 912            retval = (GLboolean) __glXReadReply(dpy, 1, res4, GL_TRUE);
 913            memcpy(residences, res4, n);
 914            free(res4);
 915         }
 916         else {
 917            retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
 918         }
 919         UnlockDisplay(dpy);
 920         SyncHandle();
 921 #endif /* USE_XCB */
 922     }
 923     return retval;
 924 }
 925
 926
 927 /**
 928  * This was previously auto-generated, but we need to special-case
 929  * how we handle writing into the 'residences' buffer when n%4!=0.
 930  */
 931 #define X_GLvop_AreTexturesResidentEXT 11
 932 GLboolean
 933 glAreTexturesResidentEXT(GLsizei n, const GLuint * textures,
 934                          GLboolean * residences)
 935 {
 936     __GLXcontext *const gc = __glXGetCurrentContext();
 937
 938     if (gc->isDirect) {
 939         return CALL_AreTexturesResident(GET_DISPATCH(),
 940                                         (n, textures, residences));
 941     } else {
 942         __GLXcontext *const gc = __glXGetCurrentContext();
 943         Display *const dpy = gc->currentDpy;
 944         GLboolean retval = (GLboolean) 0;
 945         const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
 946         if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
 947             GLubyte const *pc =
 948                 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
 949                                         X_GLvop_AreTexturesResidentEXT,
 950                                         cmdlen);
 951             (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
 952             (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
 953             if (n & 3) {
 954                /* see comments in __indirect_glAreTexturesResident() */
 955                GLboolean *res4 = malloc((n + 3) & ~3);
 956                retval = (GLboolean) __glXReadReply(dpy, 1, res4, GL_TRUE);
 957                memcpy(residences, res4, n);
 958                free(res4);
 959             }
 960             else {
 961                retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
 962             }
 963             UnlockDisplay(dpy);
 964             SyncHandle();
 965         }
 966         return retval;
 967     }
 968 }