src/mesa/main/get.c

   1 /*
   2  * Copyright (C) 2010  Brian Paul   All Rights Reserved.
   3  * Copyright (C) 2010  Intel Corporation
   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 and this permission notice shall be included
  13  * in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Author: Kristian Høgsberg <krh@bitplanet.net>
  24  */
  25
  26 #include "glheader.h"
  27 #include "context.h"
  28 #include "blend.h"
  29 #include "enable.h"
  30 #include "enums.h"
  31 #include "extensions.h"
  32 #include "get.h"
  33 #include "macros.h"
  34 #include "mtypes.h"
  35 #include "state.h"
  36 #include "texcompress.h"
  37 #include "framebuffer.h"
  38 #include "samplerobj.h"
  39
  40 /* This is a table driven implemetation of the glGet*v() functions.
  41  * The basic idea is that most getters just look up an int somewhere
  42  * in struct gl_context and then convert it to a bool or float according to
  43  * which of glGetIntegerv() glGetBooleanv() etc is being called.
  44  * Instead of generating code to do this, we can just record the enum
  45  * value and the offset into struct gl_context in an array of structs.  Then
  46  * in glGet*(), we lookup the struct for the enum in question, and use
  47  * the offset to get the int we need.
  48  *
  49  * Sometimes we need to look up a float, a boolean, a bit in a
  50  * bitfield, a matrix or other types instead, so we need to track the
  51  * type of the value in struct gl_context.  And sometimes the value isn't in
  52  * struct gl_context but in the drawbuffer, the array object, current texture
  53  * unit, or maybe it's a computed value.  So we need to also track
  54  * where or how to find the value.  Finally, we sometimes need to
  55  * check that one of a number of extensions are enabled, the GL
  56  * version or flush or call _mesa_update_state().  This is done by
  57  * attaching optional extra information to the value description
  58  * struct, it's sort of like an array of opcodes that describe extra
  59  * checks or actions.
  60  *
  61  * Putting all this together we end up with struct value_desc below,
  62  * and with a couple of macros to help, the table of struct value_desc
  63  * is about as concise as the specification in the old python script.
  64  */
  65
  66 #define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
  67 #define FLOAT_TO_FIXED(F)     ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \
  68                                 ((F) * 65536.0f < INT_MIN) ? INT_MIN : \
  69                                 (GLint) ((F) * 65536.0f) )
  70
  71 #define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
  72 #define INT_TO_FIXED(I)       ( ((I) > SHRT_MAX) ? INT_MAX : \
  73                                 ((I) < SHRT_MIN) ? INT_MIN : \
  74                                 (GLint) ((I) * 65536) )
  75
  76 #define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
  77 #define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
  78
  79 #define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
  80 #define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
  81 #define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
  82 #define BOOLEAN_TO_FIXED(B)   ( (GLint) ((B) ? 1 : 0) << 16 )
  83
  84 #define ENUM_TO_INT64(E)      ( (GLint64) (E) )
  85 #define ENUM_TO_FIXED(E)      (E)
  86
  87 enum value_type {
  88    TYPE_INVALID,
  89    TYPE_INT,
  90    TYPE_INT_2,
  91    TYPE_INT_3,
  92    TYPE_INT_4,
  93    TYPE_INT_N,
  94    TYPE_INT64,
  95    TYPE_ENUM,
  96    TYPE_ENUM_2,
  97    TYPE_BOOLEAN,
  98    TYPE_BIT_0,
  99    TYPE_BIT_1,
 100    TYPE_BIT_2,
 101    TYPE_BIT_3,
 102    TYPE_BIT_4,
 103    TYPE_BIT_5,
 104    TYPE_BIT_6,
 105    TYPE_BIT_7,
 106    TYPE_FLOAT,
 107    TYPE_FLOAT_2,
 108    TYPE_FLOAT_3,
 109    TYPE_FLOAT_4,
 110    TYPE_FLOATN,
 111    TYPE_FLOATN_2,
 112    TYPE_FLOATN_3,
 113    TYPE_FLOATN_4,
 114    TYPE_DOUBLEN,
 115    TYPE_MATRIX,
 116    TYPE_MATRIX_T,
 117    TYPE_CONST
 118 };
 119
 120 enum value_location {
 121    LOC_BUFFER,
 122    LOC_CONTEXT,
 123    LOC_ARRAY,
 124    LOC_TEXUNIT,
 125    LOC_CUSTOM
 126 };
 127
 128 enum value_extra {
 129    EXTRA_END = 0x8000,
 130    EXTRA_VERSION_30,
 131    EXTRA_VERSION_31,
 132    EXTRA_VERSION_32,
 133    EXTRA_API_GL,
 134    EXTRA_API_GL_CORE,
 135    EXTRA_API_ES2,
 136    EXTRA_API_ES3,
 137    EXTRA_NEW_BUFFERS,
 138    EXTRA_NEW_FRAG_CLAMP,
 139    EXTRA_VALID_DRAW_BUFFER,
 140    EXTRA_VALID_TEXTURE_UNIT,
 141    EXTRA_VALID_CLIP_DISTANCE,
 142    EXTRA_FLUSH_CURRENT,
 143    EXTRA_GLSL_130,
 144 };
 145
 146 #define NO_EXTRA NULL
 147 #define NO_OFFSET 0
 148
 149 struct value_desc {
 150    GLenum pname;
 151    GLubyte location;  /**< enum value_location */
 152    GLubyte type;      /**< enum value_type */
 153    int offset;
 154    const int *extra;
 155 };
 156
 157 union value {
 158    GLfloat value_float;
 159    GLfloat value_float_4[4];
 160    GLmatrix *value_matrix;
 161    GLint value_int;
 162    GLint value_int_4[4];
 163    GLint64 value_int64;
 164    GLenum value_enum;
 165
 166    /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
 167    struct {
 168       GLint n, ints[100];
 169    } value_int_n;
 170    GLboolean value_bool;
 171 };
 172
 173 #define BUFFER_FIELD(field, type) \
 174    LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)
 175 #define CONTEXT_FIELD(field, type) \
 176    LOC_CONTEXT, type, offsetof(struct gl_context, field)
 177 #define ARRAY_FIELD(field, type) \
 178    LOC_ARRAY, type, offsetof(struct gl_array_object, field)
 179 #undef CONST /* already defined through windows.h */
 180 #define CONST(value) \
 181    LOC_CONTEXT, TYPE_CONST, value
 182
 183 #define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
 184 #define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
 185 #define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
 186
 187 #define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
 188 #define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
 189 #define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
 190 #define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
 191 #define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
 192 #define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
 193 #define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)
 194 #define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)
 195 #define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)
 196 #define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)
 197 #define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)
 198 #define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)
 199 #define CONTEXT_BIT6(field) CONTEXT_FIELD(field, TYPE_BIT_6)
 200 #define CONTEXT_BIT7(field) CONTEXT_FIELD(field, TYPE_BIT_7)
 201 #define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)
 202 #define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)
 203 #define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)
 204 #define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)
 205 #define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
 206 #define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
 207
 208 #define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
 209 #define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
 210 #define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
 211
 212 #define EXT(f)                                  \
 213    offsetof(struct gl_extensions, f)
 214
 215 #define EXTRA_EXT(e)                            \
 216    static const int extra_##e[] = {             \
 217       EXT(e), EXTRA_END                         \
 218    }
 219
 220 #define EXTRA_EXT2(e1, e2)                      \
 221    static const int extra_##e1##_##e2[] = {     \
 222       EXT(e1), EXT(e2), EXTRA_END               \
 223    }
 224
 225 /* The 'extra' mechanism is a way to specify extra checks (such as
 226  * extensions or specific gl versions) or actions (flush current, new
 227  * buffers) that we need to do before looking up an enum.  We need to
 228  * declare them all up front so we can refer to them in the value_desc
 229  * structs below. */
 230
 231 static const int extra_new_buffers[] = {
 232    EXTRA_NEW_BUFFERS,
 233    EXTRA_END
 234 };
 235
 236 static const int extra_new_frag_clamp[] = {
 237    EXTRA_NEW_FRAG_CLAMP,
 238    EXTRA_END
 239 };
 240
 241 static const int extra_valid_draw_buffer[] = {
 242    EXTRA_VALID_DRAW_BUFFER,
 243    EXTRA_END
 244 };
 245
 246 static const int extra_valid_texture_unit[] = {
 247    EXTRA_VALID_TEXTURE_UNIT,
 248    EXTRA_END
 249 };
 250
 251 static const int extra_valid_clip_distance[] = {
 252    EXTRA_VALID_CLIP_DISTANCE,
 253    EXTRA_END
 254 };
 255
 256 static const int extra_flush_current_valid_texture_unit[] = {
 257    EXTRA_FLUSH_CURRENT,
 258    EXTRA_VALID_TEXTURE_UNIT,
 259    EXTRA_END
 260 };
 261
 262 static const int extra_flush_current[] = {
 263    EXTRA_FLUSH_CURRENT,
 264    EXTRA_END
 265 };
 266
 267 static const int extra_EXT_secondary_color_flush_current[] = {
 268    EXT(EXT_secondary_color),
 269    EXTRA_FLUSH_CURRENT,
 270    EXTRA_END
 271 };
 272
 273 static const int extra_EXT_fog_coord_flush_current[] = {
 274    EXT(EXT_fog_coord),
 275    EXTRA_FLUSH_CURRENT,
 276    EXTRA_END
 277 };
 278
 279 static const int extra_EXT_texture_integer[] = {
 280    EXT(EXT_texture_integer),
 281    EXTRA_END
 282 };
 283
 284 static const int extra_EXT_texture_integer_and_new_buffers[] = {
 285    EXT(EXT_texture_integer),
 286    EXTRA_NEW_BUFFERS,
 287    EXTRA_END
 288 };
 289
 290 static const int extra_GLSL_130[] = {
 291    EXTRA_GLSL_130,
 292    EXTRA_END
 293 };
 294
 295 static const int extra_texture_buffer_object[] = {
 296    EXTRA_API_GL_CORE,
 297    EXTRA_VERSION_31,
 298    EXT(ARB_texture_buffer_object),
 299    EXTRA_END
 300 };
 301
 302 static const int extra_ARB_transform_feedback2_api_es3[] = {
 303    EXT(ARB_transform_feedback2),
 304    EXTRA_API_ES3,
 305    EXTRA_END
 306 };
 307
 308 static const int extra_ARB_uniform_buffer_object_and_geometry_shader[] = {
 309    EXT(ARB_uniform_buffer_object),
 310    EXT(ARB_geometry_shader4),
 311    EXTRA_END
 312 };
 313
 314 static const int extra_ARB_ES2_compatibility_api_es2[] = {
 315    EXT(ARB_ES2_compatibility),
 316    EXTRA_API_ES2,
 317    EXTRA_END
 318 };
 319
 320 static const int extra_ARB_ES3_compatibility_api_es3[] = {
 321    EXT(ARB_ES3_compatibility),
 322    EXTRA_API_ES3,
 323    EXTRA_END
 324 };
 325
 326 static const int extra_EXT_framebuffer_sRGB_and_new_buffers[] = {
 327    EXT(EXT_framebuffer_sRGB),
 328    EXTRA_NEW_BUFFERS,
 329    EXTRA_END
 330 };
 331
 332 EXTRA_EXT(ARB_texture_cube_map);
 333 EXTRA_EXT(MESA_texture_array);
 334 EXTRA_EXT2(EXT_secondary_color, ARB_vertex_program);
 335 EXTRA_EXT(EXT_secondary_color);
 336 EXTRA_EXT(EXT_fog_coord);
 337 EXTRA_EXT(NV_fog_distance);
 338 EXTRA_EXT(EXT_texture_filter_anisotropic);
 339 EXTRA_EXT(NV_point_sprite);
 340 EXTRA_EXT(NV_texture_rectangle);
 341 EXTRA_EXT(EXT_stencil_two_side);
 342 EXTRA_EXT(EXT_depth_bounds_test);
 343 EXTRA_EXT(ARB_depth_clamp);
 344 EXTRA_EXT(ATI_fragment_shader);
 345 EXTRA_EXT(EXT_framebuffer_blit);
 346 EXTRA_EXT(ARB_shader_objects);
 347 EXTRA_EXT(EXT_provoking_vertex);
 348 EXTRA_EXT(ARB_fragment_shader);
 349 EXTRA_EXT(ARB_fragment_program);
 350 EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);
 351 EXTRA_EXT(EXT_framebuffer_object);
 352 EXTRA_EXT(ARB_seamless_cube_map);
 353 EXTRA_EXT(ARB_sync);
 354 EXTRA_EXT(ARB_vertex_shader);
 355 EXTRA_EXT(EXT_transform_feedback);
 356 EXTRA_EXT(ARB_transform_feedback3);
 357 EXTRA_EXT(EXT_pixel_buffer_object);
 358 EXTRA_EXT(ARB_vertex_program);
 359 EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);
 360 EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);
 361 EXTRA_EXT(ARB_geometry_shader4);
 362 EXTRA_EXT(ARB_color_buffer_float);
 363 EXTRA_EXT(EXT_framebuffer_sRGB);
 364 EXTRA_EXT(OES_EGL_image_external);
 365 EXTRA_EXT(ARB_blend_func_extended);
 366 EXTRA_EXT(ARB_uniform_buffer_object);
 367 EXTRA_EXT(ARB_timer_query);
 368 EXTRA_EXT(ARB_map_buffer_alignment);
 369 EXTRA_EXT(ARB_texture_cube_map_array);
 370 EXTRA_EXT(ARB_texture_buffer_range);
 371 EXTRA_EXT(ARB_texture_multisample);
 372
 373 static const int
 374 extra_ARB_color_buffer_float_or_glcore[] = {
 375    EXT(ARB_color_buffer_float),
 376    EXTRA_API_GL_CORE,
 377    EXTRA_END
 378 };
 379
 380 static const int
 381 extra_NV_primitive_restart[] = {
 382    EXT(NV_primitive_restart),
 383    EXTRA_END
 384 };
 385
 386 static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
 387 static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
 388 static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
 389
 390 static const int extra_gl30_es3[] = {
 391     EXTRA_VERSION_30,
 392     EXTRA_API_ES3,
 393     EXTRA_END,
 394 };
 395
 396 static const int
 397 extra_ARB_vertex_program_api_es2[] = {
 398    EXT(ARB_vertex_program),
 399    EXTRA_API_ES2,
 400    EXTRA_END
 401 };
 402
 403 /* The ReadBuffer get token is valid under either full GL or under
 404  * GLES2 if the NV_read_buffer extension is available. */
 405 static const int
 406 extra_NV_read_buffer_api_gl[] = {
 407    EXTRA_API_ES2,
 408    EXTRA_API_GL,
 409    EXTRA_END
 410 };
 411
 412 static const int extra_core_ARB_color_buffer_float_and_new_buffers[] = {
 413    EXTRA_API_GL_CORE,
 414    EXT(ARB_color_buffer_float),
 415    EXTRA_NEW_BUFFERS,
 416    EXTRA_END
 417 };
 418
 419 /* This is the big table describing all the enums we accept in
 420  * glGet*v().  The table is partitioned into six parts: enums
 421  * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
 422  * between OpenGL and GLES, enums exclusive to GLES, etc for the
 423  * remaining combinations. To look up the enums valid in a given API
 424  * we will use a hash table specific to that API. These tables are in
 425  * turn generated at build time and included through get_hash.h.
 426  */
 427
 428 #include "get_hash.h"
 429
 430 /* All we need now is a way to look up the value struct from the enum.
 431  * The code generated by gcc for the old generated big switch
 432  * statement is a big, balanced, open coded if/else tree, essentially
 433  * an unrolled binary search.  It would be natural to sort the new
 434  * enum table and use bsearch(), but we will use a read-only hash
 435  * table instead.  bsearch() has a nice guaranteed worst case
 436  * performance, but we're also guaranteed to hit that worst case
 437  * (log2(n) iterations) for about half the enums.  Instead, using an
 438  * open addressing hash table, we can find the enum on the first try
 439  * for 80% of the enums, 1 collision for 10% and never more than 5
 440  * collisions for any enum (typical numbers).  And the code is very
 441  * simple, even though it feels a little magic. */
 442
 443 #ifdef GET_DEBUG
 444 static void
 445 print_table_stats(int api)
 446 {
 447    int i, j, collisions[11], count, hash, mask;
 448    const struct value_desc *d;
 449    const char *api_names[] = {
 450       [API_OPENGL_COMPAT] = "GL",
 451       [API_OPENGL_CORE] = "GL_CORE",
 452       [API_OPENGLES] = "GLES",
 453       [API_OPENGLES2] = "GLES2",
 454    };
 455    const char *api_name;
 456
 457    api_name = api < Elements(api_names) ? api_names[api] : "N/A";
 458    count = 0;
 459    mask = Elements(table(api)) - 1;
 460    memset(collisions, 0, sizeof collisions);
 461
 462    for (i = 0; i < Elements(table(api)); i++) {
 463       if (!table(api)[i])
 464          continue;
 465       count++;
 466       d = &values[table(api)[i]];
 467       hash = (d->pname * prime_factor);
 468       j = 0;
 469       while (1) {
 470          if (values[table(api)[hash & mask]].pname == d->pname)
 471             break;
 472          hash += prime_step;
 473          j++;
 474       }
 475
 476       if (j < 10)
 477          collisions[j]++;
 478       else
 479          collisions[10]++;
 480    }
 481
 482    printf("number of enums for %s: %d (total %ld)\n",
 483          api_name, count, Elements(values));
 484    for (i = 0; i < Elements(collisions) - 1; i++)
 485       if (collisions[i] > 0)
 486          printf("  %d enums with %d %scollisions\n",
 487                collisions[i], i, i == 10 ? "or more " : "");
 488 }
 489 #endif
 490
 491 /**
 492  * Initialize the enum hash for a given API
 493  *
 494  * This is called from one_time_init() to insert the enum values that
 495  * are valid for the API in question into the enum hash table.
 496  *
 497  * \param the current context, for determining the API in question
 498  */
 499 void _mesa_init_get_hash(struct gl_context *ctx)
 500 {
 501 #ifdef GET_DEBUG
 502    print_table_stats();
 503 #endif
 504 }
 505
 506 /**
 507  * Handle irregular enums
 508  *
 509  * Some values don't conform to the "well-known type at context
 510  * pointer + offset" pattern, so we have this function to catch all
 511  * the corner cases.  Typically, it's a computed value or a one-off
 512  * pointer to a custom struct or something.
 513  *
 514  * In this case we can't return a pointer to the value, so we'll have
 515  * to use the temporary variable 'v' declared back in the calling
 516  * glGet*v() function to store the result.
 517  *
 518  * \param ctx the current context
 519  * \param d the struct value_desc that describes the enum
 520  * \param v pointer to the tmp declared in the calling glGet*v() function
 521  */
 522 static void
 523 find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)
 524 {
 525    struct gl_buffer_object **buffer_obj;
 526    struct gl_client_array *array;
 527    GLuint unit, *p;
 528
 529    switch (d->pname) {
 530    case GL_MAJOR_VERSION:
 531       v->value_int = ctx->Version / 10;
 532       break;
 533    case GL_MINOR_VERSION:
 534       v->value_int = ctx->Version % 10;
 535       break;
 536
 537    case GL_TEXTURE_1D:
 538    case GL_TEXTURE_2D:
 539    case GL_TEXTURE_3D:
 540    case GL_TEXTURE_1D_ARRAY_EXT:
 541    case GL_TEXTURE_2D_ARRAY_EXT:
 542    case GL_TEXTURE_CUBE_MAP_ARB:
 543    case GL_TEXTURE_RECTANGLE_NV:
 544    case GL_TEXTURE_EXTERNAL_OES:
 545       v->value_bool = _mesa_IsEnabled(d->pname);
 546       break;
 547
 548    case GL_LINE_STIPPLE_PATTERN:
 549       /* This is the only GLushort, special case it here by promoting
 550        * to an int rather than introducing a new type. */
 551       v->value_int = ctx->Line.StipplePattern;
 552       break;
 553
 554    case GL_CURRENT_RASTER_TEXTURE_COORDS:
 555       unit = ctx->Texture.CurrentUnit;
 556       v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];
 557       v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];
 558       v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];
 559       v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];
 560       break;
 561
 562    case GL_CURRENT_TEXTURE_COORDS:
 563       unit = ctx->Texture.CurrentUnit;
 564       v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];
 565       v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];
 566       v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];
 567       v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];
 568       break;
 569
 570    case GL_COLOR_WRITEMASK:
 571       v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;
 572       v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;
 573       v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;
 574       v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;
 575       break;
 576
 577    case GL_EDGE_FLAG:
 578       v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0;
 579       break;
 580
 581    case GL_READ_BUFFER:
 582       v->value_enum = ctx->ReadBuffer->ColorReadBuffer;
 583       break;
 584
 585    case GL_MAP2_GRID_DOMAIN:
 586       v->value_float_4[0] = ctx->Eval.MapGrid2u1;
 587       v->value_float_4[1] = ctx->Eval.MapGrid2u2;
 588       v->value_float_4[2] = ctx->Eval.MapGrid2v1;
 589       v->value_float_4[3] = ctx->Eval.MapGrid2v2;
 590       break;
 591
 592    case GL_TEXTURE_STACK_DEPTH:
 593       unit = ctx->Texture.CurrentUnit;
 594       v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;
 595       break;
 596    case GL_TEXTURE_MATRIX:
 597       unit = ctx->Texture.CurrentUnit;
 598       v->value_matrix = ctx->TextureMatrixStack[unit].Top;
 599       break;
 600
 601    case GL_TEXTURE_COORD_ARRAY:
 602    case GL_TEXTURE_COORD_ARRAY_SIZE:
 603    case GL_TEXTURE_COORD_ARRAY_TYPE:
 604    case GL_TEXTURE_COORD_ARRAY_STRIDE:
 605       array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
 606       v->value_int = *(GLuint *) ((char *) array + d->offset);
 607       break;
 608
 609    case GL_ACTIVE_TEXTURE_ARB:
 610       v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
 611       break;
 612    case GL_CLIENT_ACTIVE_TEXTURE_ARB:
 613       v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
 614       break;
 615
 616    case GL_MODELVIEW_STACK_DEPTH:
 617    case GL_PROJECTION_STACK_DEPTH:
 618       v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;
 619       break;
 620
 621    case GL_MAX_TEXTURE_SIZE:
 622    case GL_MAX_3D_TEXTURE_SIZE:
 623    case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
 624       p = (GLuint *) ((char *) ctx + d->offset);
 625       v->value_int = 1 << (*p - 1);
 626       break;
 627
 628    case GL_SCISSOR_BOX:
 629       v->value_int_4[0] = ctx->Scissor.X;
 630       v->value_int_4[1] = ctx->Scissor.Y;
 631       v->value_int_4[2] = ctx->Scissor.Width;
 632       v->value_int_4[3] = ctx->Scissor.Height;
 633       break;
 634
 635    case GL_LIST_INDEX:
 636       v->value_int =
 637          ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
 638       break;
 639    case GL_LIST_MODE:
 640       if (!ctx->CompileFlag)
 641          v->value_enum = 0;
 642       else if (ctx->ExecuteFlag)
 643          v->value_enum = GL_COMPILE_AND_EXECUTE;
 644       else
 645          v->value_enum = GL_COMPILE;
 646       break;
 647
 648    case GL_VIEWPORT:
 649       v->value_int_4[0] = ctx->Viewport.X;
 650       v->value_int_4[1] = ctx->Viewport.Y;
 651       v->value_int_4[2] = ctx->Viewport.Width;
 652       v->value_int_4[3] = ctx->Viewport.Height;
 653       break;
 654
 655    case GL_ACTIVE_STENCIL_FACE_EXT:
 656       v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;
 657       break;
 658
 659    case GL_STENCIL_FAIL:
 660       v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];
 661       break;
 662    case GL_STENCIL_FUNC:
 663       v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];
 664       break;
 665    case GL_STENCIL_PASS_DEPTH_FAIL:
 666       v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];
 667       break;
 668    case GL_STENCIL_PASS_DEPTH_PASS:
 669       v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];
 670       break;
 671    case GL_STENCIL_REF:
 672       v->value_int = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
 673       break;
 674    case GL_STENCIL_VALUE_MASK:
 675       v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
 676       break;
 677    case GL_STENCIL_WRITEMASK:
 678       v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
 679       break;
 680
 681    case GL_NUM_EXTENSIONS:
 682       v->value_int = _mesa_get_extension_count(ctx);
 683       break;
 684
 685    case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
 686       v->value_int = _mesa_get_color_read_type(ctx);
 687       break;
 688    case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
 689       v->value_int = _mesa_get_color_read_format(ctx);
 690       break;
 691
 692    case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
 693       v->value_int = ctx->CurrentStack->Depth + 1;
 694       break;
 695    case GL_CURRENT_MATRIX_ARB:
 696    case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
 697       v->value_matrix = ctx->CurrentStack->Top;
 698       break;
 699
 700    case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
 701       v->value_int = _mesa_get_compressed_formats(ctx, NULL);
 702       break;
 703    case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
 704       v->value_int_n.n =
 705          _mesa_get_compressed_formats(ctx, v->value_int_n.ints);
 706       ASSERT(v->value_int_n.n <= 100);
 707       break;
 708
 709    case GL_MAX_VARYING_FLOATS_ARB:
 710       v->value_int = ctx->Const.MaxVarying * 4;
 711       break;
 712
 713    /* Various object names */
 714
 715    case GL_TEXTURE_BINDING_1D:
 716    case GL_TEXTURE_BINDING_2D:
 717    case GL_TEXTURE_BINDING_3D:
 718    case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
 719    case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
 720    case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
 721    case GL_TEXTURE_BINDING_RECTANGLE_NV:
 722    case GL_TEXTURE_BINDING_EXTERNAL_OES:
 723    case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
 724    case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
 725    case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
 726       unit = ctx->Texture.CurrentUnit;
 727       v->value_int =
 728          ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
 729       break;
 730
 731    /* GL_ARB_vertex_buffer_object */
 732    case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
 733    case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
 734    case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
 735    case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
 736    case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
 737    case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
 738    case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
 739       buffer_obj = (struct gl_buffer_object **)
 740          ((char *) ctx->Array.ArrayObj + d->offset);
 741       v->value_int = (*buffer_obj)->Name;
 742       break;
 743    case GL_ARRAY_BUFFER_BINDING_ARB:
 744       v->value_int = ctx->Array.ArrayBufferObj->Name;
 745       break;
 746    case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
 747       v->value_int =
 748          ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name;
 749       break;
 750    case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
 751       v->value_int = ctx->Array.ArrayObj->ElementArrayBufferObj->Name;
 752       break;
 753
 754    /* ARB_copy_buffer */
 755    case GL_COPY_READ_BUFFER:
 756       v->value_int = ctx->CopyReadBuffer->Name;
 757       break;
 758    case GL_COPY_WRITE_BUFFER:
 759       v->value_int = ctx->CopyWriteBuffer->Name;
 760       break;
 761
 762    case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
 763       v->value_int = ctx->Pack.BufferObj->Name;
 764       break;
 765    case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
 766       v->value_int = ctx->Unpack.BufferObj->Name;
 767       break;
 768    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
 769       v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
 770       break;
 771    case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
 772       v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
 773       break;
 774    case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
 775       v->value_int = ctx->TransformFeedback.CurrentObject->Active;
 776       break;
 777    case GL_TRANSFORM_FEEDBACK_BINDING:
 778       v->value_int = ctx->TransformFeedback.CurrentObject->Name;
 779       break;
 780    case GL_CURRENT_PROGRAM:
 781       v->value_int =
 782          ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
 783       break;
 784    case GL_READ_FRAMEBUFFER_BINDING_EXT:
 785       v->value_int = ctx->ReadBuffer->Name;
 786       break;
 787    case GL_RENDERBUFFER_BINDING_EXT:
 788       v->value_int =
 789          ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
 790       break;
 791    case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
 792       v->value_int = ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].BufferObj->Name;
 793       break;
 794
 795    case GL_FOG_COLOR:
 796       if (_mesa_get_clamp_fragment_color(ctx))
 797          COPY_4FV(v->value_float_4, ctx->Fog.Color);
 798       else
 799          COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped);
 800       break;
 801    case GL_COLOR_CLEAR_VALUE:
 802       if (_mesa_get_clamp_fragment_color(ctx)) {
 803          v->value_float_4[0] = CLAMP(ctx->Color.ClearColor.f[0], 0.0F, 1.0F);
 804          v->value_float_4[1] = CLAMP(ctx->Color.ClearColor.f[1], 0.0F, 1.0F);
 805          v->value_float_4[2] = CLAMP(ctx->Color.ClearColor.f[2], 0.0F, 1.0F);
 806          v->value_float_4[3] = CLAMP(ctx->Color.ClearColor.f[3], 0.0F, 1.0F);
 807       } else
 808          COPY_4FV(v->value_float_4, ctx->Color.ClearColor.f);
 809       break;
 810    case GL_BLEND_COLOR_EXT:
 811       if (_mesa_get_clamp_fragment_color(ctx))
 812          COPY_4FV(v->value_float_4, ctx->Color.BlendColor);
 813       else
 814          COPY_4FV(v->value_float_4, ctx->Color.BlendColorUnclamped);
 815       break;
 816    case GL_ALPHA_TEST_REF:
 817       if (_mesa_get_clamp_fragment_color(ctx))
 818          v->value_float = ctx->Color.AlphaRef;
 819       else
 820          v->value_float = ctx->Color.AlphaRefUnclamped;
 821       break;
 822    case GL_MAX_VERTEX_UNIFORM_VECTORS:
 823       v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;
 824       break;
 825
 826    case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
 827       v->value_int = ctx->Const.FragmentProgram.MaxUniformComponents / 4;
 828       break;
 829
 830    /* GL_ARB_texture_buffer_object */
 831    case GL_TEXTURE_BUFFER_ARB:
 832       v->value_int = ctx->Texture.BufferObject->Name;
 833       break;
 834    case GL_TEXTURE_BINDING_BUFFER_ARB:
 835       unit = ctx->Texture.CurrentUnit;
 836       v->value_int =
 837          ctx->Texture.Unit[unit].CurrentTex[TEXTURE_BUFFER_INDEX]->Name;
 838       break;
 839    case GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB:
 840       {
 841          struct gl_buffer_object *buf =
 842             ctx->Texture.Unit[ctx->Texture.CurrentUnit]
 843             .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObject;
 844          v->value_int = buf ? buf->Name : 0;
 845       }
 846       break;
 847    case GL_TEXTURE_BUFFER_FORMAT_ARB:
 848       v->value_int = ctx->Texture.Unit[ctx->Texture.CurrentUnit]
 849          .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObjectFormat;
 850       break;
 851
 852    /* GL_ARB_sampler_objects */
 853    case GL_SAMPLER_BINDING:
 854       {
 855          struct gl_sampler_object *samp =
 856             ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler;
 857
 858          /*
 859           * The sampler object may have been deleted on another context,
 860           * so we try to lookup the sampler object before returning its Name.
 861           */
 862          if (samp && _mesa_lookup_samplerobj(ctx, samp->Name)) {
 863             v->value_int = samp->Name;
 864          } else {
 865             v->value_int = 0;
 866          }
 867       }
 868       break;
 869    /* GL_ARB_uniform_buffer_object */
 870    case GL_UNIFORM_BUFFER_BINDING:
 871       v->value_int = ctx->UniformBuffer->Name;
 872       break;
 873    /* GL_ARB_timer_query */
 874    case GL_TIMESTAMP:
 875       if (ctx->Driver.GetTimestamp) {
 876          v->value_int64 = ctx->Driver.GetTimestamp(ctx);
 877       }
 878       else {
 879          _mesa_problem(ctx, "driver doesn't implement GetTimestamp");
 880       }
 881       break;
 882    }
 883 }
 884
 885 /**
 886  * Check extra constraints on a struct value_desc descriptor
 887  *
 888  * If a struct value_desc has a non-NULL extra pointer, it means that
 889  * there are a number of extra constraints to check or actions to
 890  * perform.  The extras is just an integer array where each integer
 891  * encode different constraints or actions.
 892  *
 893  * \param ctx current context
 894  * \param func name of calling glGet*v() function for error reporting
 895  * \param d the struct value_desc that has the extra constraints
 896  *
 897  * \return GL_FALSE if all of the constraints were not satisfied,
 898  *     otherwise GL_TRUE.
 899  */
 900 static GLboolean
 901 check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)
 902 {
 903    const GLuint version = ctx->Version;
 904    GLboolean api_check = GL_FALSE;
 905    GLboolean api_found = GL_FALSE;
 906    const int *e;
 907
 908    for (e = d->extra; *e != EXTRA_END; e++) {
 909       switch (*e) {
 910       case EXTRA_VERSION_30:
 911          api_check = GL_TRUE;
 912          if (version >= 30)
 913             api_found = GL_TRUE;
 914          break;
 915       case EXTRA_VERSION_31:
 916          api_check = GL_TRUE;
 917          if (version >= 31)
 918             api_found = GL_TRUE;
 919          break;
 920       case EXTRA_VERSION_32:
 921          api_check = GL_TRUE;
 922          if (version >= 32)
 923             api_found = GL_TRUE;
 924          break;
 925       case EXTRA_NEW_FRAG_CLAMP:
 926          if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
 927             _mesa_update_state(ctx);
 928          break;
 929       case EXTRA_API_ES2:
 930          api_check = GL_TRUE;
 931          if (ctx->API == API_OPENGLES2)
 932             api_found = GL_TRUE;
 933          break;
 934       case EXTRA_API_ES3:
 935          api_check = GL_TRUE;
 936          if (_mesa_is_gles3(ctx))
 937             api_found = GL_TRUE;
 938          break;
 939       case EXTRA_API_GL:
 940          api_check = GL_TRUE;
 941          if (_mesa_is_desktop_gl(ctx))
 942             api_found = GL_TRUE;
 943          break;
 944       case EXTRA_API_GL_CORE:
 945          api_check = GL_TRUE;
 946          if (ctx->API == API_OPENGL_CORE)
 947             api_found = GL_TRUE;
 948          break;
 949       case EXTRA_NEW_BUFFERS:
 950          if (ctx->NewState & _NEW_BUFFERS)
 951             _mesa_update_state(ctx);
 952          break;
 953       case EXTRA_FLUSH_CURRENT:
 954          FLUSH_CURRENT(ctx, 0);
 955          break;
 956       case EXTRA_VALID_DRAW_BUFFER:
 957          if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
 958             _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
 959                         func, d->pname - GL_DRAW_BUFFER0_ARB);
 960             return GL_FALSE;
 961          }
 962          break;
 963       case EXTRA_VALID_TEXTURE_UNIT:
 964          if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 965             _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
 966                         func, ctx->Texture.CurrentUnit);
 967             return GL_FALSE;
 968          }
 969          break;
 970       case EXTRA_VALID_CLIP_DISTANCE:
 971          if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) {
 972             _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)",
 973                         func, d->pname - GL_CLIP_DISTANCE0);
 974             return GL_FALSE;
 975          }
 976          break;
 977       case EXTRA_GLSL_130:
 978          api_check = GL_TRUE;
 979          if (ctx->Const.GLSLVersion >= 130)
 980             api_found = GL_TRUE;
 981          break;
 982       case EXTRA_END:
 983          break;
 984       default: /* *e is a offset into the extension struct */
 985          api_check = GL_TRUE;
 986          if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
 987             api_found = GL_TRUE;
 988          break;
 989       }
 990    }
 991
 992    if (api_check && !api_found) {
 993       _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
 994                   _mesa_lookup_enum_by_nr(d->pname));
 995       return GL_FALSE;
 996    }
 997
 998    return GL_TRUE;
 999 }
1000
1001 static const struct value_desc error_value =
1002    { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
1003
1004 /**
1005  * Find the struct value_desc corresponding to the enum 'pname'.
1006  *
1007  * We hash the enum value to get an index into the 'table' array,
1008  * which holds the index in the 'values' array of struct value_desc.
1009  * Once we've found the entry, we do the extra checks, if any, then
1010  * look up the value and return a pointer to it.
1011  *
1012  * If the value has to be computed (for example, it's the result of a
1013  * function call or we need to add 1 to it), we use the tmp 'v' to
1014  * store the result.
1015  *
1016  * \param func name of glGet*v() func for error reporting
1017  * \param pname the enum value we're looking up
1018  * \param p is were we return the pointer to the value
1019  * \param v a tmp union value variable in the calling glGet*v() function
1020  *
1021  * \return the struct value_desc corresponding to the enum or a struct
1022  *     value_desc of TYPE_INVALID if not found.  This lets the calling
1023  *     glGet*v() function jump right into a switch statement and
1024  *     handle errors there instead of having to check for NULL.
1025  */
1026 static const struct value_desc *
1027 find_value(const char *func, GLenum pname, void **p, union value *v)
1028 {
1029    GET_CURRENT_CONTEXT(ctx);
1030    struct gl_texture_unit *unit;
1031    int mask, hash;
1032    const struct value_desc *d;
1033    int api;
1034
1035    api = ctx->API;
1036    /* We index into the table_set[] list of per-API hash tables using the API's
1037     * value in the gl_api enum. Since GLES 3 doesn't have an API_OPENGL* enum
1038     * value since it's compatible with GLES2 its entry in table_set[] is at the
1039     * end.
1040     */
1041    STATIC_ASSERT(Elements(table_set) == API_OPENGL_LAST + 2);
1042    if (_mesa_is_gles3(ctx)) {
1043       api = API_OPENGL_LAST + 1;
1044    }
1045    mask = Elements(table(api)) - 1;
1046    hash = (pname * prime_factor);
1047    while (1) {
1048       int idx = table(api)[hash & mask];
1049
1050       /* If the enum isn't valid, the hash walk ends with index 0,
1051        * pointing to the first entry of values[] which doesn't hold
1052        * any valid enum. */
1053       if (unlikely(idx == 0)) {
1054          _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1055                _mesa_lookup_enum_by_nr(pname));
1056          return &error_value;
1057       }
1058
1059       d = &values[idx];
1060       if (likely(d->pname == pname))
1061          break;
1062
1063       hash += prime_step;
1064    }
1065
1066    if (unlikely(d->extra && !check_extra(ctx, func, d)))
1067       return &error_value;
1068
1069    switch (d->location) {
1070    case LOC_BUFFER:
1071       *p = ((char *) ctx->DrawBuffer + d->offset);
1072       return d;
1073    case LOC_CONTEXT:
1074       *p = ((char *) ctx + d->offset);
1075       return d;
1076    case LOC_ARRAY:
1077       *p = ((char *) ctx->Array.ArrayObj + d->offset);
1078       return d;
1079    case LOC_TEXUNIT:
1080       unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1081       *p = ((char *) unit + d->offset);
1082       return d;
1083    case LOC_CUSTOM:
1084       find_custom_value(ctx, d, v);
1085       *p = v;
1086       return d;
1087    default:
1088       assert(0);
1089       break;
1090    }
1091
1092    /* silence warning */
1093    return &error_value;
1094 }
1095
1096 static const int transpose[] = {
1097    0, 4,  8, 12,
1098    1, 5,  9, 13,
1099    2, 6, 10, 14,
1100    3, 7, 11, 15
1101 };
1102
1103 void GLAPIENTRY
1104 _mesa_GetBooleanv(GLenum pname, GLboolean *params)
1105 {
1106    const struct value_desc *d;
1107    union value v;
1108    GLmatrix *m;
1109    int shift, i;
1110    void *p;
1111
1112    d = find_value("glGetBooleanv", pname, &p, &v);
1113    switch (d->type) {
1114    case TYPE_INVALID:
1115       break;
1116    case TYPE_CONST:
1117       params[0] = INT_TO_BOOLEAN(d->offset);
1118       break;
1119
1120    case TYPE_FLOAT_4:
1121    case TYPE_FLOATN_4:
1122       params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
1123    case TYPE_FLOAT_3:
1124    case TYPE_FLOATN_3:
1125       params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
1126    case TYPE_FLOAT_2:
1127    case TYPE_FLOATN_2:
1128       params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
1129    case TYPE_FLOAT:
1130    case TYPE_FLOATN:
1131       params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
1132       break;
1133
1134    case TYPE_DOUBLEN:
1135       params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
1136       break;
1137
1138    case TYPE_INT_4:
1139       params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
1140    case TYPE_INT_3:
1141       params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
1142    case TYPE_INT_2:
1143    case TYPE_ENUM_2:
1144       params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
1145    case TYPE_INT:
1146    case TYPE_ENUM:
1147       params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
1148       break;
1149
1150    case TYPE_INT_N:
1151       for (i = 0; i < v.value_int_n.n; i++)
1152          params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
1153       break;
1154
1155    case TYPE_INT64:
1156       params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
1157       break;
1158
1159    case TYPE_BOOLEAN:
1160       params[0] = ((GLboolean*) p)[0];
1161       break;
1162
1163    case TYPE_MATRIX:
1164       m = *(GLmatrix **) p;
1165       for (i = 0; i < 16; i++)
1166          params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
1167       break;
1168
1169    case TYPE_MATRIX_T:
1170       m = *(GLmatrix **) p;
1171       for (i = 0; i < 16; i++)
1172          params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
1173       break;
1174
1175    case TYPE_BIT_0:
1176    case TYPE_BIT_1:
1177    case TYPE_BIT_2:
1178    case TYPE_BIT_3:
1179    case TYPE_BIT_4:
1180    case TYPE_BIT_5:
1181    case TYPE_BIT_6:
1182    case TYPE_BIT_7:
1183       shift = d->type - TYPE_BIT_0;
1184       params[0] = (*(GLbitfield *) p >> shift) & 1;
1185       break;
1186    }
1187 }
1188
1189 void GLAPIENTRY
1190 _mesa_GetFloatv(GLenum pname, GLfloat *params)
1191 {
1192    const struct value_desc *d;
1193    union value v;
1194    GLmatrix *m;
1195    int shift, i;
1196    void *p;
1197
1198    d = find_value("glGetFloatv", pname, &p, &v);
1199    switch (d->type) {
1200    case TYPE_INVALID:
1201       break;
1202    case TYPE_CONST:
1203       params[0] = (GLfloat) d->offset;
1204       break;
1205
1206    case TYPE_FLOAT_4:
1207    case TYPE_FLOATN_4:
1208       params[3] = ((GLfloat *) p)[3];
1209    case TYPE_FLOAT_3:
1210    case TYPE_FLOATN_3:
1211       params[2] = ((GLfloat *) p)[2];
1212    case TYPE_FLOAT_2:
1213    case TYPE_FLOATN_2:
1214       params[1] = ((GLfloat *) p)[1];
1215    case TYPE_FLOAT:
1216    case TYPE_FLOATN:
1217       params[0] = ((GLfloat *) p)[0];
1218       break;
1219
1220    case TYPE_DOUBLEN:
1221       params[0] = (GLfloat) (((GLdouble *) p)[0]);
1222       break;
1223
1224    case TYPE_INT_4:
1225       params[3] = (GLfloat) (((GLint *) p)[3]);
1226    case TYPE_INT_3:
1227       params[2] = (GLfloat) (((GLint *) p)[2]);
1228    case TYPE_INT_2:
1229    case TYPE_ENUM_2:
1230       params[1] = (GLfloat) (((GLint *) p)[1]);
1231    case TYPE_INT:
1232    case TYPE_ENUM:
1233       params[0] = (GLfloat) (((GLint *) p)[0]);
1234       break;
1235
1236    case TYPE_INT_N:
1237       for (i = 0; i < v.value_int_n.n; i++)
1238          params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]);
1239       break;
1240
1241    case TYPE_INT64:
1242       params[0] = (GLfloat) (((GLint64 *) p)[0]);
1243       break;
1244
1245    case TYPE_BOOLEAN:
1246       params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
1247       break;
1248
1249    case TYPE_MATRIX:
1250       m = *(GLmatrix **) p;
1251       for (i = 0; i < 16; i++)
1252          params[i] = m->m[i];
1253       break;
1254
1255    case TYPE_MATRIX_T:
1256       m = *(GLmatrix **) p;
1257       for (i = 0; i < 16; i++)
1258          params[i] = m->m[transpose[i]];
1259       break;
1260
1261    case TYPE_BIT_0:
1262    case TYPE_BIT_1:
1263    case TYPE_BIT_2:
1264    case TYPE_BIT_3:
1265    case TYPE_BIT_4:
1266    case TYPE_BIT_5:
1267    case TYPE_BIT_6:
1268    case TYPE_BIT_7:
1269       shift = d->type - TYPE_BIT_0;
1270       params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);
1271       break;
1272    }
1273 }
1274
1275 void GLAPIENTRY
1276 _mesa_GetIntegerv(GLenum pname, GLint *params)
1277 {
1278    const struct value_desc *d;
1279    union value v;
1280    GLmatrix *m;
1281    int shift, i;
1282    void *p;
1283
1284    d = find_value("glGetIntegerv", pname, &p, &v);
1285    switch (d->type) {
1286    case TYPE_INVALID:
1287       break;
1288    case TYPE_CONST:
1289       params[0] = d->offset;
1290       break;
1291
1292    case TYPE_FLOAT_4:
1293       params[3] = IROUND(((GLfloat *) p)[3]);
1294    case TYPE_FLOAT_3:
1295       params[2] = IROUND(((GLfloat *) p)[2]);
1296    case TYPE_FLOAT_2:
1297       params[1] = IROUND(((GLfloat *) p)[1]);
1298    case TYPE_FLOAT:
1299       params[0] = IROUND(((GLfloat *) p)[0]);
1300       break;
1301
1302    case TYPE_FLOATN_4:
1303       params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
1304    case TYPE_FLOATN_3:
1305       params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
1306    case TYPE_FLOATN_2:
1307       params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
1308    case TYPE_FLOATN:
1309       params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
1310       break;
1311
1312    case TYPE_DOUBLEN:
1313       params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
1314       break;
1315
1316    case TYPE_INT_4:
1317       params[3] = ((GLint *) p)[3];
1318    case TYPE_INT_3:
1319       params[2] = ((GLint *) p)[2];
1320    case TYPE_INT_2:
1321    case TYPE_ENUM_2:
1322       params[1] = ((GLint *) p)[1];
1323    case TYPE_INT:
1324    case TYPE_ENUM:
1325       params[0] = ((GLint *) p)[0];
1326       break;
1327
1328    case TYPE_INT_N:
1329       for (i = 0; i < v.value_int_n.n; i++)
1330          params[i] = v.value_int_n.ints[i];
1331       break;
1332
1333    case TYPE_INT64:
1334       params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
1335       break;
1336
1337    case TYPE_BOOLEAN:
1338       params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
1339       break;
1340
1341    case TYPE_MATRIX:
1342       m = *(GLmatrix **) p;
1343       for (i = 0; i < 16; i++)
1344          params[i] = FLOAT_TO_INT(m->m[i]);
1345       break;
1346
1347    case TYPE_MATRIX_T:
1348       m = *(GLmatrix **) p;
1349       for (i = 0; i < 16; i++)
1350          params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
1351       break;
1352
1353    case TYPE_BIT_0:
1354    case TYPE_BIT_1:
1355    case TYPE_BIT_2:
1356    case TYPE_BIT_3:
1357    case TYPE_BIT_4:
1358    case TYPE_BIT_5:
1359    case TYPE_BIT_6:
1360    case TYPE_BIT_7:
1361       shift = d->type - TYPE_BIT_0;
1362       params[0] = (*(GLbitfield *) p >> shift) & 1;
1363       break;
1364    }
1365 }
1366
1367 void GLAPIENTRY
1368 _mesa_GetInteger64v(GLenum pname, GLint64 *params)
1369 {
1370    const struct value_desc *d;
1371    union value v;
1372    GLmatrix *m;
1373    int shift, i;
1374    void *p;
1375
1376    d = find_value("glGetInteger64v", pname, &p, &v);
1377    switch (d->type) {
1378    case TYPE_INVALID:
1379       break;
1380    case TYPE_CONST:
1381       params[0] = d->offset;
1382       break;
1383
1384    case TYPE_FLOAT_4:
1385       params[3] = IROUND64(((GLfloat *) p)[3]);
1386    case TYPE_FLOAT_3:
1387       params[2] = IROUND64(((GLfloat *) p)[2]);
1388    case TYPE_FLOAT_2:
1389       params[1] = IROUND64(((GLfloat *) p)[1]);
1390    case TYPE_FLOAT:
1391       params[0] = IROUND64(((GLfloat *) p)[0]);
1392       break;
1393
1394    case TYPE_FLOATN_4:
1395       params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]);
1396    case TYPE_FLOATN_3:
1397       params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]);
1398    case TYPE_FLOATN_2:
1399       params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]);
1400    case TYPE_FLOATN:
1401       params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]);
1402       break;
1403
1404    case TYPE_DOUBLEN:
1405       params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]);
1406       break;
1407
1408    case TYPE_INT_4:
1409       params[3] = ((GLint *) p)[3];
1410    case TYPE_INT_3:
1411       params[2] = ((GLint *) p)[2];
1412    case TYPE_INT_2:
1413    case TYPE_ENUM_2:
1414       params[1] = ((GLint *) p)[1];
1415    case TYPE_INT:
1416    case TYPE_ENUM:
1417       params[0] = ((GLint *) p)[0];
1418       break;
1419
1420    case TYPE_INT_N:
1421       for (i = 0; i < v.value_int_n.n; i++)
1422          params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
1423       break;
1424
1425    case TYPE_INT64:
1426       params[0] = ((GLint64 *) p)[0];
1427       break;
1428
1429    case TYPE_BOOLEAN:
1430       params[0] = ((GLboolean*) p)[0];
1431       break;
1432
1433    case TYPE_MATRIX:
1434       m = *(GLmatrix **) p;
1435       for (i = 0; i < 16; i++)
1436          params[i] = FLOAT_TO_INT64(m->m[i]);
1437       break;
1438
1439    case TYPE_MATRIX_T:
1440       m = *(GLmatrix **) p;
1441       for (i = 0; i < 16; i++)
1442          params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
1443       break;
1444
1445    case TYPE_BIT_0:
1446    case TYPE_BIT_1:
1447    case TYPE_BIT_2:
1448    case TYPE_BIT_3:
1449    case TYPE_BIT_4:
1450    case TYPE_BIT_5:
1451    case TYPE_BIT_6:
1452    case TYPE_BIT_7:
1453       shift = d->type - TYPE_BIT_0;
1454       params[0] = (*(GLbitfield *) p >> shift) & 1;
1455       break;
1456    }
1457 }
1458
1459 void GLAPIENTRY
1460 _mesa_GetDoublev(GLenum pname, GLdouble *params)
1461 {
1462    const struct value_desc *d;
1463    union value v;
1464    GLmatrix *m;
1465    int shift, i;
1466    void *p;
1467
1468    d = find_value("glGetDoublev", pname, &p, &v);
1469    switch (d->type) {
1470    case TYPE_INVALID:
1471       break;
1472    case TYPE_CONST:
1473       params[0] = d->offset;
1474       break;
1475
1476    case TYPE_FLOAT_4:
1477    case TYPE_FLOATN_4:
1478       params[3] = ((GLfloat *) p)[3];
1479    case TYPE_FLOAT_3:
1480    case TYPE_FLOATN_3:
1481       params[2] = ((GLfloat *) p)[2];
1482    case TYPE_FLOAT_2:
1483    case TYPE_FLOATN_2:
1484       params[1] = ((GLfloat *) p)[1];
1485    case TYPE_FLOAT:
1486    case TYPE_FLOATN:
1487       params[0] = ((GLfloat *) p)[0];
1488       break;
1489
1490    case TYPE_DOUBLEN:
1491       params[0] = ((GLdouble *) p)[0];
1492       break;
1493
1494    case TYPE_INT_4:
1495       params[3] = ((GLint *) p)[3];
1496    case TYPE_INT_3:
1497       params[2] = ((GLint *) p)[2];
1498    case TYPE_INT_2:
1499    case TYPE_ENUM_2:
1500       params[1] = ((GLint *) p)[1];
1501    case TYPE_INT:
1502    case TYPE_ENUM:
1503       params[0] = ((GLint *) p)[0];
1504       break;
1505
1506    case TYPE_INT_N:
1507       for (i = 0; i < v.value_int_n.n; i++)
1508          params[i] = v.value_int_n.ints[i];
1509       break;
1510
1511    case TYPE_INT64:
1512       params[0] = (GLdouble) (((GLint64 *) p)[0]);
1513       break;
1514
1515    case TYPE_BOOLEAN:
1516       params[0] = *(GLboolean*) p;
1517       break;
1518
1519    case TYPE_MATRIX:
1520       m = *(GLmatrix **) p;
1521       for (i = 0; i < 16; i++)
1522          params[i] = m->m[i];
1523       break;
1524
1525    case TYPE_MATRIX_T:
1526       m = *(GLmatrix **) p;
1527       for (i = 0; i < 16; i++)
1528          params[i] = m->m[transpose[i]];
1529       break;
1530
1531    case TYPE_BIT_0:
1532    case TYPE_BIT_1:
1533    case TYPE_BIT_2:
1534    case TYPE_BIT_3:
1535    case TYPE_BIT_4:
1536    case TYPE_BIT_5:
1537    case TYPE_BIT_6:
1538    case TYPE_BIT_7:
1539       shift = d->type - TYPE_BIT_0;
1540       params[0] = (*(GLbitfield *) p >> shift) & 1;
1541       break;
1542    }
1543 }
1544
1545 static enum value_type
1546 find_value_indexed(const char *func, GLenum pname, GLuint index, union value *v)
1547 {
1548    GET_CURRENT_CONTEXT(ctx);
1549
1550    switch (pname) {
1551
1552    case GL_BLEND:
1553       if (index >= ctx->Const.MaxDrawBuffers)
1554          goto invalid_value;
1555       if (!ctx->Extensions.EXT_draw_buffers2)
1556          goto invalid_enum;
1557       v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
1558       return TYPE_INT;
1559
1560    case GL_BLEND_SRC:
1561       /* fall-through */
1562    case GL_BLEND_SRC_RGB:
1563       if (index >= ctx->Const.MaxDrawBuffers)
1564          goto invalid_value;
1565       if (!ctx->Extensions.ARB_draw_buffers_blend)
1566          goto invalid_enum;
1567       v->value_int = ctx->Color.Blend[index].SrcRGB;
1568       return TYPE_INT;
1569    case GL_BLEND_SRC_ALPHA:
1570       if (index >= ctx->Const.MaxDrawBuffers)
1571          goto invalid_value;
1572       if (!ctx->Extensions.ARB_draw_buffers_blend)
1573          goto invalid_enum;
1574       v->value_int = ctx->Color.Blend[index].SrcA;
1575       return TYPE_INT;
1576    case GL_BLEND_DST:
1577       /* fall-through */
1578    case GL_BLEND_DST_RGB:
1579       if (index >= ctx->Const.MaxDrawBuffers)
1580          goto invalid_value;
1581       if (!ctx->Extensions.ARB_draw_buffers_blend)
1582          goto invalid_enum;
1583       v->value_int = ctx->Color.Blend[index].DstRGB;
1584       return TYPE_INT;
1585    case GL_BLEND_DST_ALPHA:
1586       if (index >= ctx->Const.MaxDrawBuffers)
1587          goto invalid_value;
1588       if (!ctx->Extensions.ARB_draw_buffers_blend)
1589          goto invalid_enum;
1590       v->value_int = ctx->Color.Blend[index].DstA;
1591       return TYPE_INT;
1592    case GL_BLEND_EQUATION_RGB:
1593       if (index >= ctx->Const.MaxDrawBuffers)
1594          goto invalid_value;
1595       if (!ctx->Extensions.ARB_draw_buffers_blend)
1596          goto invalid_enum;
1597       v->value_int = ctx->Color.Blend[index].EquationRGB;
1598       return TYPE_INT;
1599    case GL_BLEND_EQUATION_ALPHA:
1600       if (index >= ctx->Const.MaxDrawBuffers)
1601          goto invalid_value;
1602       if (!ctx->Extensions.ARB_draw_buffers_blend)
1603          goto invalid_enum;
1604       v->value_int = ctx->Color.Blend[index].EquationA;
1605       return TYPE_INT;
1606
1607    case GL_COLOR_WRITEMASK:
1608       if (index >= ctx->Const.MaxDrawBuffers)
1609          goto invalid_value;
1610       if (!ctx->Extensions.EXT_draw_buffers2)
1611          goto invalid_enum;
1612       v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;
1613       v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;
1614       v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;
1615       v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;
1616       return TYPE_INT_4;
1617
1618    case GL_TRANSFORM_FEEDBACK_BUFFER_START:
1619       if (index >= ctx->Const.MaxTransformFeedbackBuffers)
1620          goto invalid_value;
1621       if (!ctx->Extensions.EXT_transform_feedback)
1622          goto invalid_enum;
1623       v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
1624       return TYPE_INT64;
1625
1626    case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
1627       if (index >= ctx->Const.MaxTransformFeedbackBuffers)
1628          goto invalid_value;
1629       if (!ctx->Extensions.EXT_transform_feedback)
1630          goto invalid_enum;
1631       v->value_int64
1632          = ctx->TransformFeedback.CurrentObject->RequestedSize[index];
1633       return TYPE_INT64;
1634
1635    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
1636       if (index >= ctx->Const.MaxTransformFeedbackBuffers)
1637          goto invalid_value;
1638       if (!ctx->Extensions.EXT_transform_feedback)
1639          goto invalid_enum;
1640       v->value_int = ctx->TransformFeedback.CurrentObject->BufferNames[index];
1641       return TYPE_INT;
1642
1643    case GL_UNIFORM_BUFFER_BINDING:
1644       if (index >= ctx->Const.MaxUniformBufferBindings)
1645          goto invalid_value;
1646       if (!ctx->Extensions.ARB_uniform_buffer_object)
1647          goto invalid_enum;
1648       v->value_int = ctx->UniformBufferBindings[index].BufferObject->Name;
1649       return TYPE_INT;
1650
1651    case GL_UNIFORM_BUFFER_START:
1652       if (index >= ctx->Const.MaxUniformBufferBindings)
1653          goto invalid_value;
1654       if (!ctx->Extensions.ARB_uniform_buffer_object)
1655          goto invalid_enum;
1656       v->value_int = ctx->UniformBufferBindings[index].Offset;
1657       return TYPE_INT;
1658
1659    case GL_UNIFORM_BUFFER_SIZE:
1660       if (index >= ctx->Const.MaxUniformBufferBindings)
1661          goto invalid_value;
1662       if (!ctx->Extensions.ARB_uniform_buffer_object)
1663          goto invalid_enum;
1664       v->value_int = ctx->UniformBufferBindings[index].Size;
1665       return TYPE_INT;
1666
1667    /* ARB_texture_multisample / GL3.2 */
1668    case GL_SAMPLE_MASK_VALUE:
1669       if (index != 0)
1670          goto invalid_value;
1671       if (!ctx->Extensions.ARB_texture_multisample)
1672          goto invalid_enum;
1673       v->value_int = ctx->Multisample.SampleMaskValue;
1674       return TYPE_INT;
1675    }
1676
1677  invalid_enum:
1678    _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1679                _mesa_lookup_enum_by_nr(pname));
1680    return TYPE_INVALID;
1681  invalid_value:
1682    _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
1683                _mesa_lookup_enum_by_nr(pname));
1684    return TYPE_INVALID;
1685 }
1686
1687 void GLAPIENTRY
1688 _mesa_GetBooleani_v( GLenum pname, GLuint index, GLboolean *params )
1689 {
1690    union value v;
1691    enum value_type type =
1692       find_value_indexed("glGetBooleani_v", pname, index, &v);
1693
1694    switch (type) {
1695    case TYPE_INT:
1696       params[0] = INT_TO_BOOLEAN(v.value_int);
1697       break;
1698    case TYPE_INT_4:
1699       params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
1700       params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
1701       params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
1702       params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
1703       break;
1704    case TYPE_INT64:
1705       params[0] = INT64_TO_BOOLEAN(v.value_int);
1706       break;
1707    default:
1708       ; /* nothing - GL error was recorded */
1709    }
1710 }
1711
1712 void GLAPIENTRY
1713 _mesa_GetIntegeri_v( GLenum pname, GLuint index, GLint *params )
1714 {
1715    union value v;
1716    enum value_type type =
1717       find_value_indexed("glGetIntegeri_v", pname, index, &v);
1718
1719    switch (type) {
1720    case TYPE_INT:
1721       params[0] = v.value_int;
1722       break;
1723    case TYPE_INT_4:
1724       params[0] = v.value_int_4[0];
1725       params[1] = v.value_int_4[1];
1726       params[2] = v.value_int_4[2];
1727       params[3] = v.value_int_4[3];
1728       break;
1729    case TYPE_INT64:
1730       params[0] = INT64_TO_INT(v.value_int);
1731       break;
1732    default:
1733       ; /* nothing - GL error was recorded */
1734    }
1735 }
1736
1737 void GLAPIENTRY
1738 _mesa_GetInteger64i_v( GLenum pname, GLuint index, GLint64 *params )
1739 {
1740    union value v;
1741    enum value_type type =
1742       find_value_indexed("glGetInteger64i_v", pname, index, &v);
1743
1744    switch (type) {
1745    case TYPE_INT:
1746       params[0] = v.value_int;
1747       break;
1748    case TYPE_INT_4:
1749       params[0] = v.value_int_4[0];
1750       params[1] = v.value_int_4[1];
1751       params[2] = v.value_int_4[2];
1752       params[3] = v.value_int_4[3];
1753       break;
1754    case TYPE_INT64:
1755       params[0] = v.value_int;
1756       break;
1757    default:
1758       ; /* nothing - GL error was recorded */
1759    }
1760 }
1761
1762 void GLAPIENTRY
1763 _mesa_GetFixedv(GLenum pname, GLfixed *params)
1764 {
1765    const struct value_desc *d;
1766    union value v;
1767    GLmatrix *m;
1768    int shift, i;
1769    void *p;
1770
1771    d = find_value("glGetDoublev", pname, &p, &v);
1772    switch (d->type) {
1773    case TYPE_INVALID:
1774       break;
1775    case TYPE_CONST:
1776       params[0] = INT_TO_FIXED(d->offset);
1777       break;
1778
1779    case TYPE_FLOAT_4:
1780    case TYPE_FLOATN_4:
1781       params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
1782    case TYPE_FLOAT_3:
1783    case TYPE_FLOATN_3:
1784       params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
1785    case TYPE_FLOAT_2:
1786    case TYPE_FLOATN_2:
1787       params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
1788    case TYPE_FLOAT:
1789    case TYPE_FLOATN:
1790       params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
1791       break;
1792
1793    case TYPE_DOUBLEN:
1794       params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
1795       break;
1796
1797    case TYPE_INT_4:
1798       params[3] = INT_TO_FIXED(((GLint *) p)[3]);
1799    case TYPE_INT_3:
1800       params[2] = INT_TO_FIXED(((GLint *) p)[2]);
1801    case TYPE_INT_2:
1802    case TYPE_ENUM_2:
1803       params[1] = INT_TO_FIXED(((GLint *) p)[1]);
1804    case TYPE_INT:
1805    case TYPE_ENUM:
1806       params[0] = INT_TO_FIXED(((GLint *) p)[0]);
1807       break;
1808
1809    case TYPE_INT_N:
1810       for (i = 0; i < v.value_int_n.n; i++)
1811          params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
1812       break;
1813
1814    case TYPE_INT64:
1815       params[0] = ((GLint64 *) p)[0];
1816       break;
1817
1818    case TYPE_BOOLEAN:
1819       params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
1820       break;
1821
1822    case TYPE_MATRIX:
1823       m = *(GLmatrix **) p;
1824       for (i = 0; i < 16; i++)
1825          params[i] = FLOAT_TO_FIXED(m->m[i]);
1826       break;
1827
1828    case TYPE_MATRIX_T:
1829       m = *(GLmatrix **) p;
1830       for (i = 0; i < 16; i++)
1831          params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
1832       break;
1833
1834    case TYPE_BIT_0:
1835    case TYPE_BIT_1:
1836    case TYPE_BIT_2:
1837    case TYPE_BIT_3:
1838    case TYPE_BIT_4:
1839    case TYPE_BIT_5:
1840    case TYPE_BIT_6:
1841    case TYPE_BIT_7:
1842       shift = d->type - TYPE_BIT_0;
1843       params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);
1844       break;
1845    }
1846 }