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