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