src/glx/x11/single2.c

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