get.c revision 993e1d59 
1/*
2 * Copyright (C) 2010  Brian Paul   All Rights Reserved.
3 * Copyright (C) 2010  Intel Corporation
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Author: Kristian Høgsberg <krh@bitplanet.net>
24 */
25
26#include "glheader.h"
27#include "context.h"
28#include "blend.h"
29#include "debug_output.h"
30#include "enable.h"
31#include "enums.h"
32#include "errors.h"
33#include "extensions.h"
34#include "get.h"
35#include "macros.h"
36#include "mtypes.h"
37#include "state.h"
38#include "texcompress.h"
39#include "texstate.h"
40#include "framebuffer.h"
41#include "samplerobj.h"
42#include "stencil.h"
43#include "version.h"
44
45/* This is a table driven implemetation of the glGet*v() functions.
46 * The basic idea is that most getters just look up an int somewhere
47 * in struct gl_context and then convert it to a bool or float according to
48 * which of glGetIntegerv() glGetBooleanv() etc is being called.
49 * Instead of generating code to do this, we can just record the enum
50 * value and the offset into struct gl_context in an array of structs.  Then
51 * in glGet*(), we lookup the struct for the enum in question, and use
52 * the offset to get the int we need.
53 *
54 * Sometimes we need to look up a float, a boolean, a bit in a
55 * bitfield, a matrix or other types instead, so we need to track the
56 * type of the value in struct gl_context.  And sometimes the value isn't in
57 * struct gl_context but in the drawbuffer, the array object, current texture
58 * unit, or maybe it's a computed value.  So we need to also track
59 * where or how to find the value.  Finally, we sometimes need to
60 * check that one of a number of extensions are enabled, the GL
61 * version or flush or call _mesa_update_state().  This is done by
62 * attaching optional extra information to the value description
63 * struct, it's sort of like an array of opcodes that describe extra
64 * checks or actions.
65 *
66 * Putting all this together we end up with struct value_desc below,
67 * and with a couple of macros to help, the table of struct value_desc
68 * is about as concise as the specification in the old python script.
69 */
70
71#define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
72#define FLOAT_TO_FIXED(F)     ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \
73                                ((F) * 65536.0f < INT_MIN) ? INT_MIN : \
74                                (GLint) ((F) * 65536.0f) )
75
76#define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
77#define INT_TO_FIXED(I)       ( ((I) > SHRT_MAX) ? INT_MAX : \
78                                ((I) < SHRT_MIN) ? INT_MIN : \
79                                (GLint) ((I) * 65536) )
80
81#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
82#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
83
84#define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
85#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
86#define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
87#define BOOLEAN_TO_FIXED(B)   ( (GLint) ((B) ? 1 : 0) << 16 )
88
89#define ENUM_TO_INT64(E)      ( (GLint64) (E) )
90#define ENUM_TO_FIXED(E)      (E)
91
92enum value_type {
93   TYPE_INVALID,
94   TYPE_INT,
95   TYPE_INT_2,
96   TYPE_INT_3,
97   TYPE_INT_4,
98   TYPE_INT_N,
99   TYPE_UINT,
100   TYPE_UINT_2,
101   TYPE_UINT_3,
102   TYPE_UINT_4,
103   TYPE_INT64,
104   TYPE_ENUM16,
105   TYPE_ENUM,
106   TYPE_ENUM_2,
107   TYPE_BOOLEAN,
108   TYPE_UBYTE,
109   TYPE_SHORT,
110   TYPE_BIT_0,
111   TYPE_BIT_1,
112   TYPE_BIT_2,
113   TYPE_BIT_3,
114   TYPE_BIT_4,
115   TYPE_BIT_5,
116   TYPE_BIT_6,
117   TYPE_BIT_7,
118   TYPE_FLOAT,
119   TYPE_FLOAT_2,
120   TYPE_FLOAT_3,
121   TYPE_FLOAT_4,
122   TYPE_FLOAT_8,
123   TYPE_FLOATN,
124   TYPE_FLOATN_2,
125   TYPE_FLOATN_3,
126   TYPE_FLOATN_4,
127   TYPE_DOUBLEN,
128   TYPE_DOUBLEN_2,
129   TYPE_MATRIX,
130   TYPE_MATRIX_T,
131   TYPE_CONST
132};
133
134enum value_location {
135   LOC_BUFFER,
136   LOC_CONTEXT,
137   LOC_ARRAY,
138   LOC_TEXUNIT,
139   LOC_CUSTOM
140};
141
142enum value_extra {
143   EXTRA_END = 0x8000,
144   EXTRA_VERSION_30,
145   EXTRA_VERSION_31,
146   EXTRA_VERSION_32,
147   EXTRA_VERSION_40,
148   EXTRA_VERSION_43,
149   EXTRA_API_GL,
150   EXTRA_API_GL_CORE,
151   EXTRA_API_ES2,
152   EXTRA_API_ES3,
153   EXTRA_API_ES31,
154   EXTRA_API_ES32,
155   EXTRA_NEW_BUFFERS,
156   EXTRA_NEW_FRAG_CLAMP,
157   EXTRA_VALID_DRAW_BUFFER,
158   EXTRA_VALID_TEXTURE_UNIT,
159   EXTRA_VALID_CLIP_DISTANCE,
160   EXTRA_FLUSH_CURRENT,
161   EXTRA_GLSL_130,
162   EXTRA_EXT_UBO_GS,
163   EXTRA_EXT_ATOMICS_GS,
164   EXTRA_EXT_SHADER_IMAGE_GS,
165   EXTRA_EXT_ATOMICS_TESS,
166   EXTRA_EXT_SHADER_IMAGE_TESS,
167   EXTRA_EXT_SSBO_GS,
168   EXTRA_EXT_FB_NO_ATTACH_GS,
169   EXTRA_EXT_ES_GS,
170   EXTRA_EXT_PROVOKING_VERTEX_32,
171};
172
173#define NO_EXTRA NULL
174#define NO_OFFSET 0
175
176struct value_desc {
177   GLenum pname;
178   GLubyte location;  /**< enum value_location */
179   GLubyte type;      /**< enum value_type */
180   int offset;
181   const int *extra;
182};
183
184union value {
185   GLfloat value_float;
186   GLfloat value_float_4[4];
187   GLdouble value_double_2[2];
188   GLmatrix *value_matrix;
189   GLint value_int;
190   GLint value_int_4[4];
191   GLint64 value_int64;
192   GLenum value_enum;
193   GLubyte value_ubyte;
194   GLshort value_short;
195   GLuint value_uint;
196
197   /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
198   struct {
199      GLint n, ints[100];
200   } value_int_n;
201   GLboolean value_bool;
202};
203
204#define BUFFER_FIELD(field, type) \
205   LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)
206#define CONTEXT_FIELD(field, type) \
207   LOC_CONTEXT, type, offsetof(struct gl_context, field)
208#define ARRAY_FIELD(field, type) \
209   LOC_ARRAY, type, offsetof(struct gl_vertex_array_object, field)
210#undef CONST /* already defined through windows.h */
211#define CONST(value) \
212   LOC_CONTEXT, TYPE_CONST, value
213
214#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
215#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
216#define BUFFER_ENUM16(field) BUFFER_FIELD(field, TYPE_ENUM16)
217#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
218
219#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
220#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
221#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
222#define CONTEXT_UINT(field) CONTEXT_FIELD(field, TYPE_UINT)
223#define CONTEXT_ENUM16(field) CONTEXT_FIELD(field, TYPE_ENUM16)
224#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
225#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
226#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
227#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)
228#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)
229#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)
230#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)
231#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)
232#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)
233#define CONTEXT_BIT6(field) CONTEXT_FIELD(field, TYPE_BIT_6)
234#define CONTEXT_BIT7(field) CONTEXT_FIELD(field, TYPE_BIT_7)
235#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)
236#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)
237#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)
238#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)
239#define CONTEXT_FLOAT8(field) CONTEXT_FIELD(field, TYPE_FLOAT_8)
240#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
241#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
242
243/* Vertex array fields */
244#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
245#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
246#define ARRAY_ENUM16(field) ARRAY_FIELD(field, TYPE_ENUM16)
247#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
248#define ARRAY_UBYTE(field) ARRAY_FIELD(field, TYPE_UBYTE)
249#define ARRAY_SHORT(field) ARRAY_FIELD(field, TYPE_SHORT)
250
251#define EXT(f)					\
252   offsetof(struct gl_extensions, f)
253
254#define EXTRA_EXT(e)				\
255   static const int extra_##e[] = {		\
256      EXT(e), EXTRA_END				\
257   }
258
259#define EXTRA_EXT2(e1, e2)			\
260   static const int extra_##e1##_##e2[] = {	\
261      EXT(e1), EXT(e2), EXTRA_END		\
262   }
263
264/* The 'extra' mechanism is a way to specify extra checks (such as
265 * extensions or specific gl versions) or actions (flush current, new
266 * buffers) that we need to do before looking up an enum.  We need to
267 * declare them all up front so we can refer to them in the value_desc
268 * structs below.
269 *
270 * Each EXTRA_ will be executed.  For EXTRA_* enums of extensions and API
271 * versions, listing multiple ones in an array means an error will be thrown
272 * only if none of them are available.  If you need to check for "AND"
273 * behavior, you would need to make a custom EXTRA_ enum.
274 */
275
276static const int extra_new_buffers[] = {
277   EXTRA_NEW_BUFFERS,
278   EXTRA_END
279};
280
281static const int extra_new_frag_clamp[] = {
282   EXTRA_NEW_FRAG_CLAMP,
283   EXTRA_END
284};
285
286static const int extra_valid_draw_buffer[] = {
287   EXTRA_VALID_DRAW_BUFFER,
288   EXTRA_END
289};
290
291static const int extra_valid_texture_unit[] = {
292   EXTRA_VALID_TEXTURE_UNIT,
293   EXTRA_END
294};
295
296static const int extra_valid_clip_distance[] = {
297   EXTRA_VALID_CLIP_DISTANCE,
298   EXTRA_END
299};
300
301static const int extra_flush_current_valid_texture_unit[] = {
302   EXTRA_FLUSH_CURRENT,
303   EXTRA_VALID_TEXTURE_UNIT,
304   EXTRA_END
305};
306
307static const int extra_flush_current[] = {
308   EXTRA_FLUSH_CURRENT,
309   EXTRA_END
310};
311
312static const int extra_EXT_texture_integer_and_new_buffers[] = {
313   EXT(EXT_texture_integer),
314   EXTRA_NEW_BUFFERS,
315   EXTRA_END
316};
317
318static const int extra_GLSL_130_es3[] = {
319   EXTRA_GLSL_130,
320   EXTRA_API_ES3,
321   EXTRA_END
322};
323
324static const int extra_texture_buffer_object[] = {
325   EXT(ARB_texture_buffer_object),
326   EXTRA_END
327};
328
329static const int extra_ARB_transform_feedback2_api_es3[] = {
330   EXT(ARB_transform_feedback2),
331   EXTRA_API_ES3,
332   EXTRA_END
333};
334
335static const int extra_ARB_uniform_buffer_object_and_geometry_shader[] = {
336   EXTRA_EXT_UBO_GS,
337   EXTRA_END
338};
339
340static const int extra_ARB_ES2_compatibility_api_es2[] = {
341   EXT(ARB_ES2_compatibility),
342   EXTRA_API_ES2,
343   EXTRA_END
344};
345
346static const int extra_ARB_ES3_compatibility_api_es3[] = {
347   EXT(ARB_ES3_compatibility),
348   EXTRA_API_ES3,
349   EXTRA_END
350};
351
352static const int extra_EXT_framebuffer_sRGB_and_new_buffers[] = {
353   EXT(EXT_framebuffer_sRGB),
354   EXTRA_NEW_BUFFERS,
355   EXTRA_END
356};
357
358static const int extra_EXT_packed_float[] = {
359   EXT(EXT_packed_float),
360   EXTRA_NEW_BUFFERS,
361   EXTRA_END
362};
363
364static const int extra_EXT_texture_array_es3[] = {
365   EXT(EXT_texture_array),
366   EXTRA_API_ES3,
367   EXTRA_END
368};
369
370static const int extra_ARB_shader_atomic_counters_and_geometry_shader[] = {
371   EXTRA_EXT_ATOMICS_GS,
372   EXTRA_END
373};
374
375static const int extra_ARB_shader_image_load_store_and_geometry_shader[] = {
376   EXTRA_EXT_SHADER_IMAGE_GS,
377   EXTRA_END
378};
379
380static const int extra_ARB_shader_atomic_counters_and_tessellation[] = {
381   EXTRA_EXT_ATOMICS_TESS,
382   EXTRA_END
383};
384
385static const int extra_ARB_shader_image_load_store_and_tessellation[] = {
386   EXTRA_EXT_SHADER_IMAGE_TESS,
387   EXTRA_END
388};
389
390/* HACK: remove when ARB_compute_shader is actually supported */
391static const int extra_ARB_compute_shader_es31[] = {
392   EXT(ARB_compute_shader),
393   EXTRA_API_ES31,
394   EXTRA_END
395};
396
397static const int extra_ARB_shader_storage_buffer_object_es31[] = {
398   EXT(ARB_shader_storage_buffer_object),
399   EXTRA_API_ES31,
400   EXTRA_END
401};
402
403static const int extra_ARB_shader_storage_buffer_object_and_geometry_shader[] = {
404   EXTRA_EXT_SSBO_GS,
405   EXTRA_END
406};
407
408static const int extra_ARB_shader_image_load_store_shader_storage_buffer_object_es31[] = {
409   EXT(ARB_shader_image_load_store),
410   EXT(ARB_shader_storage_buffer_object),
411   EXTRA_API_ES31,
412   EXTRA_END
413};
414
415static const int extra_ARB_framebuffer_no_attachments_and_geometry_shader[] = {
416   EXTRA_EXT_FB_NO_ATTACH_GS,
417   EXTRA_END
418};
419
420static const int extra_ARB_viewport_array_or_oes_geometry_shader[] = {
421   EXT(ARB_viewport_array),
422   EXTRA_EXT_ES_GS,
423   EXTRA_END
424};
425
426static const int extra_ARB_viewport_array_or_oes_viewport_array[] = {
427   EXT(ARB_viewport_array),
428   EXT(OES_viewport_array),
429   EXTRA_END
430};
431
432static const int extra_ARB_gpu_shader5_or_oes_geometry_shader[] = {
433   EXT(ARB_gpu_shader5),
434   EXTRA_EXT_ES_GS,
435   EXTRA_END
436};
437
438static const int extra_ARB_gpu_shader5_or_OES_sample_variables[] = {
439   EXT(ARB_gpu_shader5),
440   EXT(OES_sample_variables),
441   EXTRA_END
442};
443
444static const int extra_ES32[] = {
445   EXT(ARB_ES3_2_compatibility),
446   EXTRA_API_ES32,
447   EXTRA_END
448};
449
450static const int extra_KHR_robustness_or_GL[] = {
451   EXT(KHR_robustness),
452   EXTRA_API_GL,
453   EXTRA_API_GL_CORE,
454   EXTRA_END
455};
456
457static const int extra_INTEL_conservative_rasterization[] = {
458   EXT(INTEL_conservative_rasterization),
459   EXTRA_END
460};
461
462EXTRA_EXT(ARB_texture_cube_map);
463EXTRA_EXT(EXT_texture_array);
464EXTRA_EXT(NV_fog_distance);
465EXTRA_EXT(EXT_texture_filter_anisotropic);
466EXTRA_EXT(NV_point_sprite);
467EXTRA_EXT(NV_texture_rectangle);
468EXTRA_EXT(EXT_stencil_two_side);
469EXTRA_EXT(EXT_depth_bounds_test);
470EXTRA_EXT(ARB_depth_clamp);
471EXTRA_EXT(AMD_depth_clamp_separate);
472EXTRA_EXT(ATI_fragment_shader);
473EXTRA_EXT(EXT_provoking_vertex);
474EXTRA_EXT(ARB_fragment_shader);
475EXTRA_EXT(ARB_fragment_program);
476EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);
477EXTRA_EXT(ARB_seamless_cube_map);
478EXTRA_EXT(ARB_sync);
479EXTRA_EXT(ARB_vertex_shader);
480EXTRA_EXT(EXT_transform_feedback);
481EXTRA_EXT(ARB_transform_feedback3);
482EXTRA_EXT(EXT_pixel_buffer_object);
483EXTRA_EXT(ARB_vertex_program);
484EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);
485EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);
486EXTRA_EXT(ARB_color_buffer_float);
487EXTRA_EXT(EXT_framebuffer_sRGB);
488EXTRA_EXT(OES_EGL_image_external);
489EXTRA_EXT(ARB_blend_func_extended);
490EXTRA_EXT(ARB_uniform_buffer_object);
491EXTRA_EXT(ARB_timer_query);
492EXTRA_EXT2(ARB_texture_cube_map_array, OES_texture_cube_map_array);
493EXTRA_EXT(ARB_texture_buffer_range);
494EXTRA_EXT(ARB_texture_multisample);
495EXTRA_EXT(ARB_texture_gather);
496EXTRA_EXT(ARB_shader_atomic_counters);
497EXTRA_EXT(ARB_draw_indirect);
498EXTRA_EXT(ARB_shader_image_load_store);
499EXTRA_EXT(ARB_query_buffer_object);
500EXTRA_EXT2(ARB_transform_feedback3, ARB_gpu_shader5);
501EXTRA_EXT(INTEL_performance_query);
502EXTRA_EXT(ARB_explicit_uniform_location);
503EXTRA_EXT(ARB_clip_control);
504EXTRA_EXT(ARB_polygon_offset_clamp);
505EXTRA_EXT(ARB_framebuffer_no_attachments);
506EXTRA_EXT(ARB_tessellation_shader);
507EXTRA_EXT(ARB_shader_storage_buffer_object);
508EXTRA_EXT(ARB_indirect_parameters);
509EXTRA_EXT(ATI_meminfo);
510EXTRA_EXT(NVX_gpu_memory_info);
511EXTRA_EXT(ARB_cull_distance);
512EXTRA_EXT(EXT_window_rectangles);
513EXTRA_EXT(KHR_blend_equation_advanced_coherent);
514EXTRA_EXT(OES_primitive_bounding_box);
515EXTRA_EXT(ARB_compute_variable_group_size);
516EXTRA_EXT(KHR_robustness);
517EXTRA_EXT(ARB_sparse_buffer);
518EXTRA_EXT(NV_conservative_raster);
519EXTRA_EXT(NV_conservative_raster_dilate);
520EXTRA_EXT(NV_conservative_raster_pre_snap_triangles);
521EXTRA_EXT(ARB_sample_locations);
522EXTRA_EXT(AMD_framebuffer_multisample_advanced);
523
524static const int
525extra_ARB_color_buffer_float_or_glcore[] = {
526   EXT(ARB_color_buffer_float),
527   EXTRA_API_GL_CORE,
528   EXTRA_END
529};
530
531static const int
532extra_NV_primitive_restart[] = {
533   EXT(NV_primitive_restart),
534   EXTRA_END
535};
536
537static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
538static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
539static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
540static const int extra_version_43[] = { EXTRA_VERSION_43, EXTRA_END };
541
542static const int extra_gl30_es3[] = {
543    EXTRA_VERSION_30,
544    EXTRA_API_ES3,
545    EXTRA_END,
546};
547
548static const int extra_gl32_es3[] = {
549    EXTRA_VERSION_32,
550    EXTRA_API_ES3,
551    EXTRA_END,
552};
553
554static const int extra_version_32_OES_geometry_shader[] = {
555    EXTRA_VERSION_32,
556    EXTRA_EXT_ES_GS,
557    EXTRA_END
558};
559
560static const int extra_gl40_ARB_sample_shading[] = {
561   EXTRA_VERSION_40,
562   EXT(ARB_sample_shading),
563   EXTRA_END
564};
565
566static const int
567extra_ARB_vertex_program_api_es2[] = {
568   EXT(ARB_vertex_program),
569   EXTRA_API_ES2,
570   EXTRA_END
571};
572
573/* The ReadBuffer get token is valid under either full GL or under
574 * GLES2 if the NV_read_buffer extension is available. */
575static const int
576extra_NV_read_buffer_api_gl[] = {
577   EXTRA_API_ES2,
578   EXTRA_API_GL,
579   EXTRA_END
580};
581
582static const int extra_core_ARB_color_buffer_float_and_new_buffers[] = {
583   EXTRA_API_GL_CORE,
584   EXT(ARB_color_buffer_float),
585   EXTRA_NEW_BUFFERS,
586   EXTRA_END
587};
588
589static const int extra_EXT_shader_framebuffer_fetch[] = {
590   EXTRA_API_ES2,
591   EXTRA_API_ES3,
592   EXT(EXT_shader_framebuffer_fetch),
593   EXTRA_END
594};
595
596static const int extra_EXT_provoking_vertex_32[] = {
597   EXTRA_EXT_PROVOKING_VERTEX_32,
598   EXTRA_END
599};
600
601static const int extra_EXT_disjoint_timer_query[] = {
602   EXTRA_API_ES2,
603   EXTRA_API_ES3,
604   EXT(EXT_disjoint_timer_query),
605   EXTRA_END
606};
607
608
609/* This is the big table describing all the enums we accept in
610 * glGet*v().  The table is partitioned into six parts: enums
611 * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
612 * between OpenGL and GLES, enums exclusive to GLES, etc for the
613 * remaining combinations. To look up the enums valid in a given API
614 * we will use a hash table specific to that API. These tables are in
615 * turn generated at build time and included through get_hash.h.
616 */
617
618#include "get_hash.h"
619
620/* All we need now is a way to look up the value struct from the enum.
621 * The code generated by gcc for the old generated big switch
622 * statement is a big, balanced, open coded if/else tree, essentially
623 * an unrolled binary search.  It would be natural to sort the new
624 * enum table and use bsearch(), but we will use a read-only hash
625 * table instead.  bsearch() has a nice guaranteed worst case
626 * performance, but we're also guaranteed to hit that worst case
627 * (log2(n) iterations) for about half the enums.  Instead, using an
628 * open addressing hash table, we can find the enum on the first try
629 * for 80% of the enums, 1 collision for 10% and never more than 5
630 * collisions for any enum (typical numbers).  And the code is very
631 * simple, even though it feels a little magic. */
632
633/**
634 * Handle irregular enums
635 *
636 * Some values don't conform to the "well-known type at context
637 * pointer + offset" pattern, so we have this function to catch all
638 * the corner cases.  Typically, it's a computed value or a one-off
639 * pointer to a custom struct or something.
640 *
641 * In this case we can't return a pointer to the value, so we'll have
642 * to use the temporary variable 'v' declared back in the calling
643 * glGet*v() function to store the result.
644 *
645 * \param ctx the current context
646 * \param d the struct value_desc that describes the enum
647 * \param v pointer to the tmp declared in the calling glGet*v() function
648 */
649static void
650find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)
651{
652   struct gl_buffer_object **buffer_obj;
653   struct gl_array_attributes *array;
654   GLuint unit, *p;
655
656   switch (d->pname) {
657   case GL_MAJOR_VERSION:
658      v->value_int = ctx->Version / 10;
659      break;
660   case GL_MINOR_VERSION:
661      v->value_int = ctx->Version % 10;
662      break;
663
664   case GL_TEXTURE_1D:
665   case GL_TEXTURE_2D:
666   case GL_TEXTURE_3D:
667   case GL_TEXTURE_CUBE_MAP:
668   case GL_TEXTURE_RECTANGLE_NV:
669   case GL_TEXTURE_EXTERNAL_OES:
670      v->value_bool = _mesa_IsEnabled(d->pname);
671      break;
672
673   case GL_LINE_STIPPLE_PATTERN:
674      /* This is the only GLushort, special case it here by promoting
675       * to an int rather than introducing a new type. */
676      v->value_int = ctx->Line.StipplePattern;
677      break;
678
679   case GL_CURRENT_RASTER_TEXTURE_COORDS:
680      unit = ctx->Texture.CurrentUnit;
681      v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];
682      v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];
683      v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];
684      v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];
685      break;
686
687   case GL_CURRENT_TEXTURE_COORDS:
688      unit = ctx->Texture.CurrentUnit;
689      v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];
690      v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];
691      v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];
692      v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];
693      break;
694
695   case GL_COLOR_WRITEMASK:
696      v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 0);
697      v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 1);
698      v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 2);
699      v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 3);
700      break;
701
702   case GL_DEPTH_CLAMP:
703      v->value_bool = ctx->Transform.DepthClampNear || ctx->Transform.DepthClampFar;
704      break;
705
706   case GL_EDGE_FLAG:
707      v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0F;
708      break;
709
710   case GL_READ_BUFFER:
711      v->value_enum = ctx->ReadBuffer->ColorReadBuffer;
712      break;
713
714   case GL_MAP2_GRID_DOMAIN:
715      v->value_float_4[0] = ctx->Eval.MapGrid2u1;
716      v->value_float_4[1] = ctx->Eval.MapGrid2u2;
717      v->value_float_4[2] = ctx->Eval.MapGrid2v1;
718      v->value_float_4[3] = ctx->Eval.MapGrid2v2;
719      break;
720
721   case GL_TEXTURE_STACK_DEPTH:
722      unit = ctx->Texture.CurrentUnit;
723      v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;
724      break;
725   case GL_TEXTURE_MATRIX:
726      unit = ctx->Texture.CurrentUnit;
727      v->value_matrix = ctx->TextureMatrixStack[unit].Top;
728      break;
729
730   case GL_TEXTURE_COORD_ARRAY:
731   case GL_TEXTURE_COORD_ARRAY_SIZE:
732   case GL_TEXTURE_COORD_ARRAY_TYPE:
733   case GL_TEXTURE_COORD_ARRAY_STRIDE:
734      array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
735      v->value_int = *(GLuint *) ((char *) array + d->offset);
736      break;
737
738   case GL_ACTIVE_TEXTURE_ARB:
739      v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
740      break;
741   case GL_CLIENT_ACTIVE_TEXTURE_ARB:
742      v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
743      break;
744
745   case GL_MODELVIEW_STACK_DEPTH:
746   case GL_PROJECTION_STACK_DEPTH:
747      v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;
748      break;
749
750   case GL_MAX_TEXTURE_SIZE:
751   case GL_MAX_3D_TEXTURE_SIZE:
752   case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
753      p = (GLuint *) ((char *) ctx + d->offset);
754      v->value_int = 1 << (*p - 1);
755      break;
756
757   case GL_SCISSOR_BOX:
758      v->value_int_4[0] = ctx->Scissor.ScissorArray[0].X;
759      v->value_int_4[1] = ctx->Scissor.ScissorArray[0].Y;
760      v->value_int_4[2] = ctx->Scissor.ScissorArray[0].Width;
761      v->value_int_4[3] = ctx->Scissor.ScissorArray[0].Height;
762      break;
763
764   case GL_SCISSOR_TEST:
765      v->value_bool = ctx->Scissor.EnableFlags & 1;
766      break;
767
768   case GL_LIST_INDEX:
769      v->value_int =
770         ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
771      break;
772   case GL_LIST_MODE:
773      if (!ctx->CompileFlag)
774         v->value_enum = 0;
775      else if (ctx->ExecuteFlag)
776         v->value_enum = GL_COMPILE_AND_EXECUTE;
777      else
778         v->value_enum = GL_COMPILE;
779      break;
780
781   case GL_VIEWPORT:
782      v->value_float_4[0] = ctx->ViewportArray[0].X;
783      v->value_float_4[1] = ctx->ViewportArray[0].Y;
784      v->value_float_4[2] = ctx->ViewportArray[0].Width;
785      v->value_float_4[3] = ctx->ViewportArray[0].Height;
786      break;
787
788   case GL_DEPTH_RANGE:
789      v->value_double_2[0] = ctx->ViewportArray[0].Near;
790      v->value_double_2[1] = ctx->ViewportArray[0].Far;
791      break;
792
793   case GL_ACTIVE_STENCIL_FACE_EXT:
794      v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;
795      break;
796
797   case GL_STENCIL_FAIL:
798      v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];
799      break;
800   case GL_STENCIL_FUNC:
801      v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];
802      break;
803   case GL_STENCIL_PASS_DEPTH_FAIL:
804      v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];
805      break;
806   case GL_STENCIL_PASS_DEPTH_PASS:
807      v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];
808      break;
809   case GL_STENCIL_REF:
810      v->value_int = _mesa_get_stencil_ref(ctx, ctx->Stencil.ActiveFace);
811      break;
812   case GL_STENCIL_BACK_REF:
813      v->value_int = _mesa_get_stencil_ref(ctx, 1);
814      break;
815   case GL_STENCIL_VALUE_MASK:
816      v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
817      break;
818   case GL_STENCIL_WRITEMASK:
819      v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
820      break;
821
822   case GL_NUM_EXTENSIONS:
823      v->value_int = _mesa_get_extension_count(ctx);
824      break;
825
826   case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
827      v->value_int = _mesa_get_color_read_type(ctx, NULL, "glGetIntegerv");
828      break;
829   case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
830      v->value_int = _mesa_get_color_read_format(ctx, NULL, "glGetIntegerv");
831      break;
832
833   case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
834      v->value_int = ctx->CurrentStack->Depth + 1;
835      break;
836   case GL_CURRENT_MATRIX_ARB:
837   case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
838      v->value_matrix = ctx->CurrentStack->Top;
839      break;
840
841   case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
842      v->value_int = _mesa_get_compressed_formats(ctx, NULL);
843      break;
844   case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
845      v->value_int_n.n =
846         _mesa_get_compressed_formats(ctx, v->value_int_n.ints);
847      assert(v->value_int_n.n <= (int) ARRAY_SIZE(v->value_int_n.ints));
848      break;
849
850   case GL_MAX_VARYING_FLOATS_ARB:
851      v->value_int = ctx->Const.MaxVarying * 4;
852      break;
853
854   /* Various object names */
855
856   case GL_TEXTURE_BINDING_1D:
857   case GL_TEXTURE_BINDING_2D:
858   case GL_TEXTURE_BINDING_3D:
859   case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
860   case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
861   case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
862   case GL_TEXTURE_BINDING_RECTANGLE_NV:
863   case GL_TEXTURE_BINDING_EXTERNAL_OES:
864   case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
865   case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
866   case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
867      unit = ctx->Texture.CurrentUnit;
868      v->value_int =
869         ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
870      break;
871
872   /* GL_EXT_external_objects */
873   case GL_NUM_DEVICE_UUIDS_EXT:
874      v->value_int = 1;
875      break;
876   case GL_DRIVER_UUID_EXT:
877      _mesa_get_driver_uuid(ctx, v->value_int_4);
878      break;
879   case GL_DEVICE_UUID_EXT:
880      _mesa_get_device_uuid(ctx, v->value_int_4);
881      break;
882
883   /* GL_EXT_packed_float */
884   case GL_RGBA_SIGNED_COMPONENTS_EXT:
885      {
886         /* Note: we only check the 0th color attachment. */
887         const struct gl_renderbuffer *rb =
888            ctx->DrawBuffer->_ColorDrawBuffers[0];
889         if (rb && _mesa_is_format_signed(rb->Format)) {
890            /* Issue 17 of GL_EXT_packed_float:  If a component (such as
891             * alpha) has zero bits, the component should not be considered
892             * signed and so the bit for the respective component should be
893             * zeroed.
894             */
895            GLint r_bits =
896               _mesa_get_format_bits(rb->Format, GL_RED_BITS);
897            GLint g_bits =
898               _mesa_get_format_bits(rb->Format, GL_GREEN_BITS);
899            GLint b_bits =
900               _mesa_get_format_bits(rb->Format, GL_BLUE_BITS);
901            GLint a_bits =
902               _mesa_get_format_bits(rb->Format, GL_ALPHA_BITS);
903            GLint l_bits =
904               _mesa_get_format_bits(rb->Format, GL_TEXTURE_LUMINANCE_SIZE);
905            GLint i_bits =
906               _mesa_get_format_bits(rb->Format, GL_TEXTURE_INTENSITY_SIZE);
907
908            v->value_int_4[0] = r_bits + l_bits + i_bits > 0;
909            v->value_int_4[1] = g_bits + l_bits + i_bits > 0;
910            v->value_int_4[2] = b_bits + l_bits + i_bits > 0;
911            v->value_int_4[3] = a_bits + i_bits > 0;
912         }
913         else {
914            v->value_int_4[0] =
915            v->value_int_4[1] =
916            v->value_int_4[2] =
917            v->value_int_4[3] = 0;
918         }
919      }
920      break;
921
922   /* GL_ARB_vertex_buffer_object */
923   case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
924   case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
925   case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
926   case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
927   case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
928   case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
929   case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
930      buffer_obj = (struct gl_buffer_object **)
931         ((char *) ctx->Array.VAO + d->offset);
932      v->value_int = (*buffer_obj)->Name;
933      break;
934   case GL_ARRAY_BUFFER_BINDING_ARB:
935      v->value_int = ctx->Array.ArrayBufferObj->Name;
936      break;
937   case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
938      v->value_int =
939         ctx->Array.VAO->BufferBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name;
940      break;
941   case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
942      v->value_int = ctx->Array.VAO->IndexBufferObj->Name;
943      break;
944
945   /* ARB_vertex_array_bgra */
946   case GL_COLOR_ARRAY_SIZE:
947      array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0];
948      v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size;
949      break;
950   case GL_SECONDARY_COLOR_ARRAY_SIZE:
951      array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1];
952      v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size;
953      break;
954
955   /* ARB_copy_buffer */
956   case GL_COPY_READ_BUFFER:
957      v->value_int = ctx->CopyReadBuffer->Name;
958      break;
959   case GL_COPY_WRITE_BUFFER:
960      v->value_int = ctx->CopyWriteBuffer->Name;
961      break;
962
963   case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
964      v->value_int = ctx->Pack.BufferObj->Name;
965      break;
966   case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
967      v->value_int = ctx->Unpack.BufferObj->Name;
968      break;
969   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
970      v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
971      break;
972   case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
973      v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
974      break;
975   case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
976      v->value_int = ctx->TransformFeedback.CurrentObject->Active;
977      break;
978   case GL_TRANSFORM_FEEDBACK_BINDING:
979      v->value_int = ctx->TransformFeedback.CurrentObject->Name;
980      break;
981   case GL_CURRENT_PROGRAM:
982      /* The Changelog of the ARB_separate_shader_objects spec says:
983       *
984       * 24 25 Jul 2011  pbrown  Remove the language erroneously deleting
985       *                         CURRENT_PROGRAM.  In the EXT extension, this
986       *                         token was aliased to ACTIVE_PROGRAM_EXT, and
987       *                         was used to indicate the last program set by
988       *                         either ActiveProgramEXT or UseProgram.  In
989       *                         the ARB extension, the SSO active programs
990       *                         are now program pipeline object state and
991       *                         CURRENT_PROGRAM should still be used to query
992       *                         the last program set by UseProgram (bug 7822).
993       */
994      v->value_int =
995         ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
996      break;
997   case GL_READ_FRAMEBUFFER_BINDING_EXT:
998      v->value_int = ctx->ReadBuffer->Name;
999      break;
1000   case GL_RENDERBUFFER_BINDING_EXT:
1001      v->value_int =
1002         ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
1003      break;
1004   case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
1005      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_POINT_SIZE].BufferObj->Name;
1006      break;
1007
1008   case GL_FOG_COLOR:
1009      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1010         COPY_4FV(v->value_float_4, ctx->Fog.Color);
1011      else
1012         COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped);
1013      break;
1014   case GL_COLOR_CLEAR_VALUE:
1015      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer)) {
1016         v->value_float_4[0] = CLAMP(ctx->Color.ClearColor.f[0], 0.0F, 1.0F);
1017         v->value_float_4[1] = CLAMP(ctx->Color.ClearColor.f[1], 0.0F, 1.0F);
1018         v->value_float_4[2] = CLAMP(ctx->Color.ClearColor.f[2], 0.0F, 1.0F);
1019         v->value_float_4[3] = CLAMP(ctx->Color.ClearColor.f[3], 0.0F, 1.0F);
1020      } else
1021         COPY_4FV(v->value_float_4, ctx->Color.ClearColor.f);
1022      break;
1023   case GL_BLEND_COLOR_EXT:
1024      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1025         COPY_4FV(v->value_float_4, ctx->Color.BlendColor);
1026      else
1027         COPY_4FV(v->value_float_4, ctx->Color.BlendColorUnclamped);
1028      break;
1029   case GL_ALPHA_TEST_REF:
1030      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1031         v->value_float = ctx->Color.AlphaRef;
1032      else
1033         v->value_float = ctx->Color.AlphaRefUnclamped;
1034      break;
1035   case GL_MAX_VERTEX_UNIFORM_VECTORS:
1036      v->value_int = ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents / 4;
1037      break;
1038
1039   case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1040      v->value_int = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents / 4;
1041      break;
1042
1043   /* GL_ARB_texture_buffer_object */
1044   case GL_TEXTURE_BUFFER_ARB:
1045      v->value_int = ctx->Texture.BufferObject->Name;
1046      break;
1047   case GL_TEXTURE_BINDING_BUFFER_ARB:
1048      unit = ctx->Texture.CurrentUnit;
1049      v->value_int =
1050         ctx->Texture.Unit[unit].CurrentTex[TEXTURE_BUFFER_INDEX]->Name;
1051      break;
1052   case GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB:
1053      {
1054         struct gl_buffer_object *buf =
1055            ctx->Texture.Unit[ctx->Texture.CurrentUnit]
1056            .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObject;
1057         v->value_int = buf ? buf->Name : 0;
1058      }
1059      break;
1060   case GL_TEXTURE_BUFFER_FORMAT_ARB:
1061      v->value_int = ctx->Texture.Unit[ctx->Texture.CurrentUnit]
1062         .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObjectFormat;
1063      break;
1064
1065   /* GL_ARB_sampler_objects */
1066   case GL_SAMPLER_BINDING:
1067      {
1068         struct gl_sampler_object *samp =
1069            ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler;
1070         v->value_int = samp ? samp->Name : 0;
1071      }
1072      break;
1073   /* GL_ARB_uniform_buffer_object */
1074   case GL_UNIFORM_BUFFER_BINDING:
1075      v->value_int = ctx->UniformBuffer->Name;
1076      break;
1077   /* GL_ARB_shader_storage_buffer_object */
1078   case GL_SHADER_STORAGE_BUFFER_BINDING:
1079      v->value_int = ctx->ShaderStorageBuffer->Name;
1080      break;
1081   /* GL_ARB_query_buffer_object */
1082   case GL_QUERY_BUFFER_BINDING:
1083      v->value_int = ctx->QueryBuffer->Name;
1084      break;
1085   /* GL_ARB_timer_query */
1086   case GL_TIMESTAMP:
1087      if (ctx->Driver.GetTimestamp) {
1088         v->value_int64 = ctx->Driver.GetTimestamp(ctx);
1089      }
1090      else {
1091         _mesa_problem(ctx, "driver doesn't implement GetTimestamp");
1092      }
1093      break;
1094   /* GL_KHR_DEBUG */
1095   case GL_DEBUG_OUTPUT:
1096   case GL_DEBUG_OUTPUT_SYNCHRONOUS:
1097   case GL_DEBUG_LOGGED_MESSAGES:
1098   case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
1099   case GL_DEBUG_GROUP_STACK_DEPTH:
1100      v->value_int = _mesa_get_debug_state_int(ctx, d->pname);
1101      break;
1102   /* GL_ARB_shader_atomic_counters */
1103   case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1104      if (ctx->AtomicBuffer) {
1105         v->value_int = ctx->AtomicBuffer->Name;
1106      } else {
1107         v->value_int = 0;
1108      }
1109      break;
1110   /* GL 4.3 */
1111   case GL_NUM_SHADING_LANGUAGE_VERSIONS:
1112      v->value_int = _mesa_get_shading_language_version(ctx, -1, NULL);
1113      break;
1114   /* GL_ARB_draw_indirect */
1115   case GL_DRAW_INDIRECT_BUFFER_BINDING:
1116      v->value_int = ctx->DrawIndirectBuffer->Name;
1117      break;
1118   /* GL_ARB_indirect_parameters */
1119   case GL_PARAMETER_BUFFER_BINDING_ARB:
1120      v->value_int = ctx->ParameterBuffer->Name;
1121      break;
1122   /* GL_ARB_separate_shader_objects */
1123   case GL_PROGRAM_PIPELINE_BINDING:
1124      if (ctx->Pipeline.Current) {
1125         v->value_int = ctx->Pipeline.Current->Name;
1126      } else {
1127         v->value_int = 0;
1128      }
1129      break;
1130   /* GL_ARB_compute_shader */
1131   case GL_DISPATCH_INDIRECT_BUFFER_BINDING:
1132      v->value_int = ctx->DispatchIndirectBuffer->Name;
1133      break;
1134   /* GL_ARB_multisample */
1135   case GL_SAMPLES:
1136      v->value_int = _mesa_geometric_samples(ctx->DrawBuffer);
1137      break;
1138   case GL_SAMPLE_BUFFERS:
1139      v->value_int = _mesa_geometric_samples(ctx->DrawBuffer) > 0;
1140      break;
1141   /* GL_EXT_textrue_integer */
1142   case GL_RGBA_INTEGER_MODE_EXT:
1143      v->value_int = (ctx->DrawBuffer->_IntegerBuffers != 0);
1144      break;
1145   /* GL_ATI_meminfo & GL_NVX_gpu_memory_info */
1146   case GL_VBO_FREE_MEMORY_ATI:
1147   case GL_TEXTURE_FREE_MEMORY_ATI:
1148   case GL_RENDERBUFFER_FREE_MEMORY_ATI:
1149   case GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX:
1150   case GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX:
1151   case GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX:
1152   case GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX:
1153   case GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX:
1154      {
1155         struct gl_memory_info info;
1156
1157         ctx->Driver.QueryMemoryInfo(ctx, &info);
1158
1159         if (d->pname == GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX)
1160            v->value_int = info.total_device_memory;
1161         else if (d->pname == GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX)
1162            v->value_int = info.total_device_memory +
1163                           info.total_staging_memory;
1164         else if (d->pname == GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX)
1165            v->value_int = info.avail_device_memory;
1166         else if (d->pname == GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX)
1167            v->value_int = info.nr_device_memory_evictions;
1168         else if (d->pname == GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX)
1169            v->value_int = info.device_memory_evicted;
1170         else {
1171            /* ATI free memory enums.
1172             *
1173             * Since the GPU memory is (usually) page-table based, every two
1174             * consecutive elements are equal. From the GL_ATI_meminfo
1175             * specification:
1176             *
1177             *    "param[0] - total memory free in the pool
1178             *     param[1] - largest available free block in the pool
1179             *     param[2] - total auxiliary memory free
1180             *     param[3] - largest auxiliary free block"
1181             *
1182             * All three (VBO, TEXTURE, RENDERBUFFER) queries return
1183             * the same numbers here.
1184             */
1185            v->value_int_4[0] = info.avail_device_memory;
1186            v->value_int_4[1] = info.avail_device_memory;
1187            v->value_int_4[2] = info.avail_staging_memory;
1188            v->value_int_4[3] = info.avail_staging_memory;
1189         }
1190      }
1191      break;
1192
1193   /* GL_ARB_get_program_binary */
1194   case GL_PROGRAM_BINARY_FORMATS:
1195      assert(ctx->Const.NumProgramBinaryFormats <= 1);
1196      v->value_int_n.n = MIN2(ctx->Const.NumProgramBinaryFormats, 1);
1197      if (ctx->Const.NumProgramBinaryFormats > 0) {
1198         v->value_int_n.ints[0] = GL_PROGRAM_BINARY_FORMAT_MESA;
1199      }
1200      break;
1201   /* GL_EXT_disjoint_timer_query */
1202   case GL_GPU_DISJOINT_EXT:
1203      {
1204         simple_mtx_lock(&ctx->Shared->Mutex);
1205         v->value_int = ctx->Shared->DisjointOperation;
1206         /* Reset state as expected by the spec. */
1207         ctx->Shared->DisjointOperation = false;
1208         simple_mtx_unlock(&ctx->Shared->Mutex);
1209      }
1210      break;
1211   /* GL_ARB_sample_locations */
1212   case GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB:
1213   case GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB:
1214   case GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB:
1215      {
1216         GLuint bits, width, height;
1217
1218         if (ctx->NewState & _NEW_BUFFERS)
1219            _mesa_update_state(ctx);
1220
1221         if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE) {
1222            v->value_uint = 0;
1223            break;
1224         }
1225
1226         ctx->Driver.GetProgrammableSampleCaps(ctx, ctx->DrawBuffer,
1227                                               &bits, &width, &height);
1228
1229         if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB)
1230            v->value_uint = width;
1231         else if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB)
1232            v->value_uint = height;
1233         else
1234            v->value_uint = bits;
1235      }
1236      break;
1237   case GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB:
1238      v->value_uint = MAX_SAMPLE_LOCATION_TABLE_SIZE;
1239      break;
1240
1241   /* GL_AMD_framebuffer_multisample_advanced */
1242   case GL_SUPPORTED_MULTISAMPLE_MODES_AMD:
1243      v->value_int_n.n = ctx->Const.NumSupportedMultisampleModes * 3;
1244      memcpy(v->value_int_n.ints, ctx->Const.SupportedMultisampleModes,
1245             v->value_int_n.n * sizeof(GLint));
1246      break;
1247   }
1248}
1249
1250/**
1251 * Check extra constraints on a struct value_desc descriptor
1252 *
1253 * If a struct value_desc has a non-NULL extra pointer, it means that
1254 * there are a number of extra constraints to check or actions to
1255 * perform.  The extras is just an integer array where each integer
1256 * encode different constraints or actions.
1257 *
1258 * \param ctx current context
1259 * \param func name of calling glGet*v() function for error reporting
1260 * \param d the struct value_desc that has the extra constraints
1261 *
1262 * \return GL_FALSE if all of the constraints were not satisfied,
1263 *     otherwise GL_TRUE.
1264 */
1265static GLboolean
1266check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)
1267{
1268   const GLuint version = ctx->Version;
1269   GLboolean api_check = GL_FALSE;
1270   GLboolean api_found = GL_FALSE;
1271   const int *e;
1272
1273   for (e = d->extra; *e != EXTRA_END; e++) {
1274      switch (*e) {
1275      case EXTRA_VERSION_30:
1276         api_check = GL_TRUE;
1277         if (version >= 30)
1278            api_found = GL_TRUE;
1279         break;
1280      case EXTRA_VERSION_31:
1281         api_check = GL_TRUE;
1282         if (version >= 31)
1283            api_found = GL_TRUE;
1284         break;
1285      case EXTRA_VERSION_32:
1286         api_check = GL_TRUE;
1287         if (version >= 32)
1288            api_found = GL_TRUE;
1289         break;
1290      case EXTRA_VERSION_40:
1291         api_check = GL_TRUE;
1292         if (version >= 40)
1293            api_found = GL_TRUE;
1294         break;
1295      case EXTRA_VERSION_43:
1296         api_check = TRUE;
1297         if (_mesa_is_desktop_gl(ctx) && version >= 43)
1298            api_found = GL_TRUE;
1299         break;
1300      case EXTRA_NEW_FRAG_CLAMP:
1301         if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
1302            _mesa_update_state(ctx);
1303         break;
1304      case EXTRA_API_ES2:
1305         api_check = GL_TRUE;
1306         if (ctx->API == API_OPENGLES2)
1307            api_found = GL_TRUE;
1308         break;
1309      case EXTRA_API_ES3:
1310         api_check = GL_TRUE;
1311         if (_mesa_is_gles3(ctx))
1312            api_found = GL_TRUE;
1313         break;
1314      case EXTRA_API_ES31:
1315         api_check = GL_TRUE;
1316         if (_mesa_is_gles31(ctx))
1317            api_found = GL_TRUE;
1318         break;
1319      case EXTRA_API_ES32:
1320         api_check = GL_TRUE;
1321         if (_mesa_is_gles32(ctx))
1322            api_found = GL_TRUE;
1323         break;
1324      case EXTRA_API_GL:
1325         api_check = GL_TRUE;
1326         if (_mesa_is_desktop_gl(ctx))
1327            api_found = GL_TRUE;
1328         break;
1329      case EXTRA_API_GL_CORE:
1330         api_check = GL_TRUE;
1331         if (ctx->API == API_OPENGL_CORE)
1332            api_found = GL_TRUE;
1333         break;
1334      case EXTRA_NEW_BUFFERS:
1335         if (ctx->NewState & _NEW_BUFFERS)
1336            _mesa_update_state(ctx);
1337         break;
1338      case EXTRA_FLUSH_CURRENT:
1339         FLUSH_CURRENT(ctx, 0);
1340         break;
1341      case EXTRA_VALID_DRAW_BUFFER:
1342         if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
1343            _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
1344                        func, d->pname - GL_DRAW_BUFFER0_ARB);
1345            return GL_FALSE;
1346         }
1347         break;
1348      case EXTRA_VALID_TEXTURE_UNIT:
1349         if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
1350            _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
1351                        func, ctx->Texture.CurrentUnit);
1352            return GL_FALSE;
1353         }
1354         break;
1355      case EXTRA_VALID_CLIP_DISTANCE:
1356         if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) {
1357            _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)",
1358                        func, d->pname - GL_CLIP_DISTANCE0);
1359            return GL_FALSE;
1360         }
1361         break;
1362      case EXTRA_GLSL_130:
1363         api_check = GL_TRUE;
1364         if (ctx->Const.GLSLVersion >= 130)
1365            api_found = GL_TRUE;
1366         break;
1367      case EXTRA_EXT_UBO_GS:
1368         api_check = GL_TRUE;
1369         if (ctx->Extensions.ARB_uniform_buffer_object &&
1370            _mesa_has_geometry_shaders(ctx))
1371            api_found = GL_TRUE;
1372         break;
1373      case EXTRA_EXT_ATOMICS_GS:
1374         api_check = GL_TRUE;
1375         if (ctx->Extensions.ARB_shader_atomic_counters &&
1376            _mesa_has_geometry_shaders(ctx))
1377            api_found = GL_TRUE;
1378         break;
1379      case EXTRA_EXT_SHADER_IMAGE_GS:
1380         api_check = GL_TRUE;
1381         if (ctx->Extensions.ARB_shader_image_load_store &&
1382            _mesa_has_geometry_shaders(ctx))
1383            api_found = GL_TRUE;
1384         break;
1385      case EXTRA_EXT_ATOMICS_TESS:
1386         api_check = GL_TRUE;
1387         api_found = ctx->Extensions.ARB_shader_atomic_counters &&
1388                     _mesa_has_tessellation(ctx);
1389         break;
1390      case EXTRA_EXT_SHADER_IMAGE_TESS:
1391         api_check = GL_TRUE;
1392         api_found = ctx->Extensions.ARB_shader_image_load_store &&
1393                     _mesa_has_tessellation(ctx);
1394         break;
1395      case EXTRA_EXT_SSBO_GS:
1396         api_check = GL_TRUE;
1397         if (ctx->Extensions.ARB_shader_storage_buffer_object &&
1398            _mesa_has_geometry_shaders(ctx))
1399            api_found = GL_TRUE;
1400         break;
1401      case EXTRA_EXT_FB_NO_ATTACH_GS:
1402         api_check = GL_TRUE;
1403         if (ctx->Extensions.ARB_framebuffer_no_attachments &&
1404            (_mesa_is_desktop_gl(ctx) ||
1405            _mesa_has_OES_geometry_shader(ctx)))
1406            api_found = GL_TRUE;
1407         break;
1408      case EXTRA_EXT_ES_GS:
1409         api_check = GL_TRUE;
1410         if (_mesa_has_OES_geometry_shader(ctx))
1411            api_found = GL_TRUE;
1412         break;
1413      case EXTRA_EXT_PROVOKING_VERTEX_32:
1414         api_check = TRUE;
1415         if (ctx->API == API_OPENGL_COMPAT || version == 32)
1416            api_found = ctx->Extensions.EXT_provoking_vertex;
1417         break;
1418      case EXTRA_END:
1419         break;
1420      default: /* *e is a offset into the extension struct */
1421         api_check = GL_TRUE;
1422         if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
1423            api_found = GL_TRUE;
1424         break;
1425      }
1426   }
1427
1428   if (api_check && !api_found) {
1429      _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1430                  _mesa_enum_to_string(d->pname));
1431      return GL_FALSE;
1432   }
1433
1434   return GL_TRUE;
1435}
1436
1437static const struct value_desc error_value =
1438   { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
1439
1440/**
1441 * Find the struct value_desc corresponding to the enum 'pname'.
1442 *
1443 * We hash the enum value to get an index into the 'table' array,
1444 * which holds the index in the 'values' array of struct value_desc.
1445 * Once we've found the entry, we do the extra checks, if any, then
1446 * look up the value and return a pointer to it.
1447 *
1448 * If the value has to be computed (for example, it's the result of a
1449 * function call or we need to add 1 to it), we use the tmp 'v' to
1450 * store the result.
1451 *
1452 * \param func name of glGet*v() func for error reporting
1453 * \param pname the enum value we're looking up
1454 * \param p is were we return the pointer to the value
1455 * \param v a tmp union value variable in the calling glGet*v() function
1456 *
1457 * \return the struct value_desc corresponding to the enum or a struct
1458 *     value_desc of TYPE_INVALID if not found.  This lets the calling
1459 *     glGet*v() function jump right into a switch statement and
1460 *     handle errors there instead of having to check for NULL.
1461 */
1462static const struct value_desc *
1463find_value(const char *func, GLenum pname, void **p, union value *v)
1464{
1465   GET_CURRENT_CONTEXT(ctx);
1466   int mask, hash;
1467   const struct value_desc *d;
1468   int api;
1469
1470   api = ctx->API;
1471   /* We index into the table_set[] list of per-API hash tables using the API's
1472    * value in the gl_api enum. Since GLES 3 doesn't have an API_OPENGL* enum
1473    * value since it's compatible with GLES2 its entry in table_set[] is at the
1474    * end.
1475    */
1476   STATIC_ASSERT(ARRAY_SIZE(table_set) == API_OPENGL_LAST + 4);
1477   if (ctx->API == API_OPENGLES2) {
1478      if (ctx->Version >= 32)
1479         api = API_OPENGL_LAST + 3;
1480      else if (ctx->Version >= 31)
1481         api = API_OPENGL_LAST + 2;
1482      else if (ctx->Version >= 30)
1483         api = API_OPENGL_LAST + 1;
1484   }
1485   mask = ARRAY_SIZE(table(api)) - 1;
1486   hash = (pname * prime_factor);
1487   while (1) {
1488      int idx = table(api)[hash & mask];
1489
1490      /* If the enum isn't valid, the hash walk ends with index 0,
1491       * pointing to the first entry of values[] which doesn't hold
1492       * any valid enum. */
1493      if (unlikely(idx == 0)) {
1494         _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1495               _mesa_enum_to_string(pname));
1496         return &error_value;
1497      }
1498
1499      d = &values[idx];
1500      if (likely(d->pname == pname))
1501         break;
1502
1503      hash += prime_step;
1504   }
1505
1506   if (unlikely(d->extra && !check_extra(ctx, func, d)))
1507      return &error_value;
1508
1509   switch (d->location) {
1510   case LOC_BUFFER:
1511      *p = ((char *) ctx->DrawBuffer + d->offset);
1512      return d;
1513   case LOC_CONTEXT:
1514      *p = ((char *) ctx + d->offset);
1515      return d;
1516   case LOC_ARRAY:
1517      *p = ((char *) ctx->Array.VAO + d->offset);
1518      return d;
1519   case LOC_TEXUNIT:
1520      if (ctx->Texture.CurrentUnit < ARRAY_SIZE(ctx->Texture.FixedFuncUnit)) {
1521         unsigned index = ctx->Texture.CurrentUnit;
1522         *p = ((char *)&ctx->Texture.FixedFuncUnit[index] + d->offset);
1523      }
1524      return d;
1525   case LOC_CUSTOM:
1526      find_custom_value(ctx, d, v);
1527      *p = v;
1528      return d;
1529   default:
1530      assert(0);
1531      break;
1532   }
1533
1534   /* silence warning */
1535   return &error_value;
1536}
1537
1538static const int transpose[] = {
1539   0, 4,  8, 12,
1540   1, 5,  9, 13,
1541   2, 6, 10, 14,
1542   3, 7, 11, 15
1543};
1544
1545static GLsizei
1546get_value_size(enum value_type type, const union value *v)
1547{
1548   switch (type) {
1549   case TYPE_INVALID:
1550      return 0;
1551   case TYPE_CONST:
1552   case TYPE_UINT:
1553   case TYPE_INT:
1554      return sizeof(GLint);
1555   case TYPE_INT_2:
1556   case TYPE_UINT_2:
1557      return sizeof(GLint) * 2;
1558   case TYPE_INT_3:
1559   case TYPE_UINT_3:
1560      return sizeof(GLint) * 3;
1561   case TYPE_INT_4:
1562   case TYPE_UINT_4:
1563      return sizeof(GLint) * 4;
1564   case TYPE_INT_N:
1565      return sizeof(GLint) * v->value_int_n.n;
1566   case TYPE_INT64:
1567      return sizeof(GLint64);
1568      break;
1569   case TYPE_ENUM16:
1570      return sizeof(GLenum16);
1571   case TYPE_ENUM:
1572      return sizeof(GLenum);
1573   case TYPE_ENUM_2:
1574      return sizeof(GLenum) * 2;
1575   case TYPE_BOOLEAN:
1576      return sizeof(GLboolean);
1577   case TYPE_UBYTE:
1578      return sizeof(GLubyte);
1579   case TYPE_SHORT:
1580      return sizeof(GLshort);
1581   case TYPE_BIT_0:
1582   case TYPE_BIT_1:
1583   case TYPE_BIT_2:
1584   case TYPE_BIT_3:
1585   case TYPE_BIT_4:
1586   case TYPE_BIT_5:
1587   case TYPE_BIT_6:
1588   case TYPE_BIT_7:
1589      return 1;
1590   case TYPE_FLOAT:
1591   case TYPE_FLOATN:
1592      return sizeof(GLfloat);
1593   case TYPE_FLOAT_2:
1594   case TYPE_FLOATN_2:
1595      return sizeof(GLfloat) * 2;
1596   case TYPE_FLOAT_3:
1597   case TYPE_FLOATN_3:
1598      return sizeof(GLfloat) * 3;
1599   case TYPE_FLOAT_4:
1600   case TYPE_FLOATN_4:
1601      return sizeof(GLfloat) * 4;
1602   case TYPE_FLOAT_8:
1603      return sizeof(GLfloat) * 8;
1604   case TYPE_DOUBLEN:
1605      return sizeof(GLdouble);
1606   case TYPE_DOUBLEN_2:
1607      return sizeof(GLdouble) * 2;
1608   case TYPE_MATRIX:
1609      return sizeof (GLfloat) * 16;
1610   case TYPE_MATRIX_T:
1611      return sizeof (GLfloat) * 16;
1612   default:
1613      return -1;
1614   }
1615}
1616
1617void GLAPIENTRY
1618_mesa_GetBooleanv(GLenum pname, GLboolean *params)
1619{
1620   const struct value_desc *d;
1621   union value v;
1622   GLmatrix *m;
1623   int shift, i;
1624   void *p;
1625
1626   d = find_value("glGetBooleanv", pname, &p, &v);
1627   switch (d->type) {
1628   case TYPE_INVALID:
1629      break;
1630   case TYPE_CONST:
1631      params[0] = INT_TO_BOOLEAN(d->offset);
1632      break;
1633
1634   case TYPE_FLOAT_8:
1635      params[7] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[7]);
1636      params[6] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[6]);
1637      params[5] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[5]);
1638      params[4] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[4]);
1639   case TYPE_FLOAT_4:
1640   case TYPE_FLOATN_4:
1641      params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
1642   case TYPE_FLOAT_3:
1643   case TYPE_FLOATN_3:
1644      params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
1645   case TYPE_FLOAT_2:
1646   case TYPE_FLOATN_2:
1647      params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
1648   case TYPE_FLOAT:
1649   case TYPE_FLOATN:
1650      params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
1651      break;
1652
1653   case TYPE_DOUBLEN_2:
1654      params[1] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[1]);
1655   case TYPE_DOUBLEN:
1656      params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
1657      break;
1658
1659   case TYPE_INT_4:
1660   case TYPE_UINT_4:
1661      params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
1662   case TYPE_INT_3:
1663   case TYPE_UINT_3:
1664      params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
1665   case TYPE_INT_2:
1666   case TYPE_UINT_2:
1667   case TYPE_ENUM_2:
1668      params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
1669   case TYPE_INT:
1670   case TYPE_UINT:
1671   case TYPE_ENUM:
1672      params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
1673      break;
1674
1675   case TYPE_ENUM16:
1676      params[0] = INT_TO_BOOLEAN(((GLenum16 *) p)[0]);
1677      break;
1678
1679   case TYPE_INT_N:
1680      for (i = 0; i < v.value_int_n.n; i++)
1681         params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
1682      break;
1683
1684   case TYPE_INT64:
1685      params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
1686      break;
1687
1688   case TYPE_BOOLEAN:
1689      params[0] = ((GLboolean*) p)[0];
1690      break;
1691
1692   case TYPE_UBYTE:
1693      params[0] = INT_TO_BOOLEAN(((GLubyte *) p)[0]);
1694      break;
1695
1696   case TYPE_SHORT:
1697      params[0] = INT_TO_BOOLEAN(((GLshort *) p)[0]);
1698      break;
1699
1700   case TYPE_MATRIX:
1701      m = *(GLmatrix **) p;
1702      for (i = 0; i < 16; i++)
1703         params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
1704      break;
1705
1706   case TYPE_MATRIX_T:
1707      m = *(GLmatrix **) p;
1708      for (i = 0; i < 16; i++)
1709         params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
1710      break;
1711
1712   case TYPE_BIT_0:
1713   case TYPE_BIT_1:
1714   case TYPE_BIT_2:
1715   case TYPE_BIT_3:
1716   case TYPE_BIT_4:
1717   case TYPE_BIT_5:
1718   case TYPE_BIT_6:
1719   case TYPE_BIT_7:
1720      shift = d->type - TYPE_BIT_0;
1721      params[0] = (*(GLbitfield *) p >> shift) & 1;
1722      break;
1723   }
1724}
1725
1726void GLAPIENTRY
1727_mesa_GetFloatv(GLenum pname, GLfloat *params)
1728{
1729   const struct value_desc *d;
1730   union value v;
1731   GLmatrix *m;
1732   int shift, i;
1733   void *p;
1734
1735   d = find_value("glGetFloatv", pname, &p, &v);
1736   switch (d->type) {
1737   case TYPE_INVALID:
1738      break;
1739   case TYPE_CONST:
1740      params[0] = (GLfloat) d->offset;
1741      break;
1742
1743   case TYPE_FLOAT_8:
1744      params[7] = ((GLfloat *) p)[7];
1745      params[6] = ((GLfloat *) p)[6];
1746      params[5] = ((GLfloat *) p)[5];
1747      params[4] = ((GLfloat *) p)[4];
1748   case TYPE_FLOAT_4:
1749   case TYPE_FLOATN_4:
1750      params[3] = ((GLfloat *) p)[3];
1751   case TYPE_FLOAT_3:
1752   case TYPE_FLOATN_3:
1753      params[2] = ((GLfloat *) p)[2];
1754   case TYPE_FLOAT_2:
1755   case TYPE_FLOATN_2:
1756      params[1] = ((GLfloat *) p)[1];
1757   case TYPE_FLOAT:
1758   case TYPE_FLOATN:
1759      params[0] = ((GLfloat *) p)[0];
1760      break;
1761
1762   case TYPE_DOUBLEN_2:
1763      params[1] = (GLfloat) (((GLdouble *) p)[1]);
1764   case TYPE_DOUBLEN:
1765      params[0] = (GLfloat) (((GLdouble *) p)[0]);
1766      break;
1767
1768   case TYPE_INT_4:
1769      params[3] = (GLfloat) (((GLint *) p)[3]);
1770   case TYPE_INT_3:
1771      params[2] = (GLfloat) (((GLint *) p)[2]);
1772   case TYPE_INT_2:
1773   case TYPE_ENUM_2:
1774      params[1] = (GLfloat) (((GLint *) p)[1]);
1775   case TYPE_INT:
1776   case TYPE_ENUM:
1777      params[0] = (GLfloat) (((GLint *) p)[0]);
1778      break;
1779
1780   case TYPE_ENUM16:
1781      params[0] = (GLfloat) (((GLenum16 *) p)[0]);
1782      break;
1783
1784   case TYPE_INT_N:
1785      for (i = 0; i < v.value_int_n.n; i++)
1786         params[i] = (GLfloat) v.value_int_n.ints[i];
1787      break;
1788
1789   case TYPE_UINT_4:
1790      params[3] = (GLfloat) (((GLuint *) p)[3]);
1791   case TYPE_UINT_3:
1792      params[2] = (GLfloat) (((GLuint *) p)[2]);
1793   case TYPE_UINT_2:
1794      params[1] = (GLfloat) (((GLuint *) p)[1]);
1795   case TYPE_UINT:
1796      params[0] = (GLfloat) (((GLuint *) p)[0]);
1797      break;
1798
1799   case TYPE_INT64:
1800      params[0] = (GLfloat) (((GLint64 *) p)[0]);
1801      break;
1802
1803   case TYPE_BOOLEAN:
1804      params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
1805      break;
1806
1807   case TYPE_UBYTE:
1808      params[0] = (GLfloat) ((GLubyte *) p)[0];
1809      break;
1810
1811   case TYPE_SHORT:
1812      params[0] = (GLfloat) ((GLshort *) p)[0];
1813      break;
1814
1815   case TYPE_MATRIX:
1816      m = *(GLmatrix **) p;
1817      for (i = 0; i < 16; i++)
1818         params[i] = m->m[i];
1819      break;
1820
1821   case TYPE_MATRIX_T:
1822      m = *(GLmatrix **) p;
1823      for (i = 0; i < 16; i++)
1824         params[i] = m->m[transpose[i]];
1825      break;
1826
1827   case TYPE_BIT_0:
1828   case TYPE_BIT_1:
1829   case TYPE_BIT_2:
1830   case TYPE_BIT_3:
1831   case TYPE_BIT_4:
1832   case TYPE_BIT_5:
1833   case TYPE_BIT_6:
1834   case TYPE_BIT_7:
1835      shift = d->type - TYPE_BIT_0;
1836      params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);
1837      break;
1838   }
1839}
1840
1841void GLAPIENTRY
1842_mesa_GetIntegerv(GLenum pname, GLint *params)
1843{
1844   const struct value_desc *d;
1845   union value v;
1846   GLmatrix *m;
1847   int shift, i;
1848   void *p;
1849
1850   d = find_value("glGetIntegerv", pname, &p, &v);
1851   switch (d->type) {
1852   case TYPE_INVALID:
1853      break;
1854   case TYPE_CONST:
1855      params[0] = d->offset;
1856      break;
1857
1858   case TYPE_FLOAT_8:
1859      params[7] = IROUND(((GLfloat *) p)[7]);
1860      params[6] = IROUND(((GLfloat *) p)[6]);
1861      params[5] = IROUND(((GLfloat *) p)[5]);
1862      params[4] = IROUND(((GLfloat *) p)[4]);
1863   case TYPE_FLOAT_4:
1864      params[3] = IROUND(((GLfloat *) p)[3]);
1865   case TYPE_FLOAT_3:
1866      params[2] = IROUND(((GLfloat *) p)[2]);
1867   case TYPE_FLOAT_2:
1868      params[1] = IROUND(((GLfloat *) p)[1]);
1869   case TYPE_FLOAT:
1870      params[0] = IROUND(((GLfloat *) p)[0]);
1871      break;
1872
1873   case TYPE_FLOATN_4:
1874      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
1875   case TYPE_FLOATN_3:
1876      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
1877   case TYPE_FLOATN_2:
1878      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
1879   case TYPE_FLOATN:
1880      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
1881      break;
1882
1883   case TYPE_DOUBLEN_2:
1884      params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]);
1885   case TYPE_DOUBLEN:
1886      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
1887      break;
1888
1889   case TYPE_INT_4:
1890   case TYPE_UINT_4:
1891      params[3] = ((GLint *) p)[3];
1892   case TYPE_INT_3:
1893   case TYPE_UINT_3:
1894      params[2] = ((GLint *) p)[2];
1895   case TYPE_INT_2:
1896   case TYPE_UINT_2:
1897   case TYPE_ENUM_2:
1898      params[1] = ((GLint *) p)[1];
1899   case TYPE_INT:
1900   case TYPE_UINT:
1901   case TYPE_ENUM:
1902      params[0] = ((GLint *) p)[0];
1903      break;
1904
1905   case TYPE_ENUM16:
1906      params[0] = ((GLenum16 *) p)[0];
1907      break;
1908
1909   case TYPE_INT_N:
1910      for (i = 0; i < v.value_int_n.n; i++)
1911         params[i] = v.value_int_n.ints[i];
1912      break;
1913
1914   case TYPE_INT64:
1915      params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
1916      break;
1917
1918   case TYPE_BOOLEAN:
1919      params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
1920      break;
1921
1922   case TYPE_UBYTE:
1923      params[0] = ((GLubyte *) p)[0];
1924      break;
1925
1926   case TYPE_SHORT:
1927      params[0] = ((GLshort *) p)[0];
1928      break;
1929
1930   case TYPE_MATRIX:
1931      m = *(GLmatrix **) p;
1932      for (i = 0; i < 16; i++)
1933         params[i] = FLOAT_TO_INT(m->m[i]);
1934      break;
1935
1936   case TYPE_MATRIX_T:
1937      m = *(GLmatrix **) p;
1938      for (i = 0; i < 16; i++)
1939         params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
1940      break;
1941
1942   case TYPE_BIT_0:
1943   case TYPE_BIT_1:
1944   case TYPE_BIT_2:
1945   case TYPE_BIT_3:
1946   case TYPE_BIT_4:
1947   case TYPE_BIT_5:
1948   case TYPE_BIT_6:
1949   case TYPE_BIT_7:
1950      shift = d->type - TYPE_BIT_0;
1951      params[0] = (*(GLbitfield *) p >> shift) & 1;
1952      break;
1953   }
1954}
1955
1956void GLAPIENTRY
1957_mesa_GetInteger64v(GLenum pname, GLint64 *params)
1958{
1959   const struct value_desc *d;
1960   union value v;
1961   GLmatrix *m;
1962   int shift, i;
1963   void *p;
1964
1965   d = find_value("glGetInteger64v", pname, &p, &v);
1966   switch (d->type) {
1967   case TYPE_INVALID:
1968      break;
1969   case TYPE_CONST:
1970      params[0] = d->offset;
1971      break;
1972
1973   case TYPE_FLOAT_8:
1974      params[7] = IROUND64(((GLfloat *) p)[7]);
1975      params[6] = IROUND64(((GLfloat *) p)[6]);
1976      params[5] = IROUND64(((GLfloat *) p)[5]);
1977      params[4] = IROUND64(((GLfloat *) p)[4]);
1978   case TYPE_FLOAT_4:
1979      params[3] = IROUND64(((GLfloat *) p)[3]);
1980   case TYPE_FLOAT_3:
1981      params[2] = IROUND64(((GLfloat *) p)[2]);
1982   case TYPE_FLOAT_2:
1983      params[1] = IROUND64(((GLfloat *) p)[1]);
1984   case TYPE_FLOAT:
1985      params[0] = IROUND64(((GLfloat *) p)[0]);
1986      break;
1987
1988   case TYPE_FLOATN_4:
1989      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
1990   case TYPE_FLOATN_3:
1991      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
1992   case TYPE_FLOATN_2:
1993      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
1994   case TYPE_FLOATN:
1995      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
1996      break;
1997
1998   case TYPE_DOUBLEN_2:
1999      params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]);
2000   case TYPE_DOUBLEN:
2001      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
2002      break;
2003
2004   case TYPE_INT_4:
2005      params[3] = ((GLint *) p)[3];
2006   case TYPE_INT_3:
2007      params[2] = ((GLint *) p)[2];
2008   case TYPE_INT_2:
2009   case TYPE_ENUM_2:
2010      params[1] = ((GLint *) p)[1];
2011   case TYPE_INT:
2012   case TYPE_ENUM:
2013      params[0] = ((GLint *) p)[0];
2014      break;
2015
2016   case TYPE_ENUM16:
2017      params[0] = ((GLenum16 *) p)[0];
2018      break;
2019
2020   case TYPE_INT_N:
2021      for (i = 0; i < v.value_int_n.n; i++)
2022         params[i] = v.value_int_n.ints[i];
2023      break;
2024
2025   case TYPE_UINT_4:
2026      params[3] = ((GLuint *) p)[3];
2027   case TYPE_UINT_3:
2028      params[2] = ((GLuint *) p)[2];
2029   case TYPE_UINT_2:
2030      params[1] = ((GLuint *) p)[1];
2031   case TYPE_UINT:
2032      params[0] = ((GLuint *) p)[0];
2033      break;
2034
2035   case TYPE_INT64:
2036      params[0] = ((GLint64 *) p)[0];
2037      break;
2038
2039   case TYPE_BOOLEAN:
2040      params[0] = ((GLboolean*) p)[0];
2041      break;
2042
2043   case TYPE_MATRIX:
2044      m = *(GLmatrix **) p;
2045      for (i = 0; i < 16; i++)
2046         params[i] = FLOAT_TO_INT64(m->m[i]);
2047      break;
2048
2049   case TYPE_MATRIX_T:
2050      m = *(GLmatrix **) p;
2051      for (i = 0; i < 16; i++)
2052         params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
2053      break;
2054
2055   case TYPE_BIT_0:
2056   case TYPE_BIT_1:
2057   case TYPE_BIT_2:
2058   case TYPE_BIT_3:
2059   case TYPE_BIT_4:
2060   case TYPE_BIT_5:
2061   case TYPE_BIT_6:
2062   case TYPE_BIT_7:
2063      shift = d->type - TYPE_BIT_0;
2064      params[0] = (*(GLbitfield *) p >> shift) & 1;
2065      break;
2066   }
2067}
2068
2069void GLAPIENTRY
2070_mesa_GetDoublev(GLenum pname, GLdouble *params)
2071{
2072   const struct value_desc *d;
2073   union value v;
2074   GLmatrix *m;
2075   int shift, i;
2076   void *p;
2077
2078   d = find_value("glGetDoublev", pname, &p, &v);
2079   switch (d->type) {
2080   case TYPE_INVALID:
2081      break;
2082   case TYPE_CONST:
2083      params[0] = d->offset;
2084      break;
2085
2086   case TYPE_FLOAT_8:
2087      params[7] = ((GLfloat *) p)[7];
2088      params[6] = ((GLfloat *) p)[6];
2089      params[5] = ((GLfloat *) p)[5];
2090      params[4] = ((GLfloat *) p)[4];
2091   case TYPE_FLOAT_4:
2092   case TYPE_FLOATN_4:
2093      params[3] = ((GLfloat *) p)[3];
2094   case TYPE_FLOAT_3:
2095   case TYPE_FLOATN_3:
2096      params[2] = ((GLfloat *) p)[2];
2097   case TYPE_FLOAT_2:
2098   case TYPE_FLOATN_2:
2099      params[1] = ((GLfloat *) p)[1];
2100   case TYPE_FLOAT:
2101   case TYPE_FLOATN:
2102      params[0] = ((GLfloat *) p)[0];
2103      break;
2104
2105   case TYPE_DOUBLEN_2:
2106      params[1] = ((GLdouble *) p)[1];
2107   case TYPE_DOUBLEN:
2108      params[0] = ((GLdouble *) p)[0];
2109      break;
2110
2111   case TYPE_INT_4:
2112      params[3] = ((GLint *) p)[3];
2113   case TYPE_INT_3:
2114      params[2] = ((GLint *) p)[2];
2115   case TYPE_INT_2:
2116   case TYPE_ENUM_2:
2117      params[1] = ((GLint *) p)[1];
2118   case TYPE_INT:
2119   case TYPE_ENUM:
2120      params[0] = ((GLint *) p)[0];
2121      break;
2122
2123   case TYPE_ENUM16:
2124      params[0] = ((GLenum16 *) p)[0];
2125      break;
2126
2127   case TYPE_INT_N:
2128      for (i = 0; i < v.value_int_n.n; i++)
2129         params[i] = v.value_int_n.ints[i];
2130      break;
2131
2132   case TYPE_UINT_4:
2133      params[3] = ((GLuint *) p)[3];
2134   case TYPE_UINT_3:
2135      params[2] = ((GLuint *) p)[2];
2136   case TYPE_UINT_2:
2137      params[1] = ((GLuint *) p)[1];
2138   case TYPE_UINT:
2139      params[0] = ((GLuint *) p)[0];
2140      break;
2141
2142   case TYPE_INT64:
2143      params[0] = (GLdouble) (((GLint64 *) p)[0]);
2144      break;
2145
2146   case TYPE_BOOLEAN:
2147      params[0] = *(GLboolean*) p;
2148      break;
2149
2150   case TYPE_UBYTE:
2151      params[0] = ((GLubyte *) p)[0];
2152      break;
2153
2154   case TYPE_SHORT:
2155      params[0] = ((GLshort *) p)[0];
2156      break;
2157
2158   case TYPE_MATRIX:
2159      m = *(GLmatrix **) p;
2160      for (i = 0; i < 16; i++)
2161         params[i] = m->m[i];
2162      break;
2163
2164   case TYPE_MATRIX_T:
2165      m = *(GLmatrix **) p;
2166      for (i = 0; i < 16; i++)
2167         params[i] = m->m[transpose[i]];
2168      break;
2169
2170   case TYPE_BIT_0:
2171   case TYPE_BIT_1:
2172   case TYPE_BIT_2:
2173   case TYPE_BIT_3:
2174   case TYPE_BIT_4:
2175   case TYPE_BIT_5:
2176   case TYPE_BIT_6:
2177   case TYPE_BIT_7:
2178      shift = d->type - TYPE_BIT_0;
2179      params[0] = (*(GLbitfield *) p >> shift) & 1;
2180      break;
2181   }
2182}
2183
2184void GLAPIENTRY
2185_mesa_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
2186{
2187   const struct value_desc *d;
2188   union value v;
2189   int shift;
2190   void *p = NULL;
2191   GLsizei size;
2192   const char *func = "glGetUnsignedBytevEXT";
2193
2194   GET_CURRENT_CONTEXT(ctx);
2195
2196   if (!ctx->Extensions.EXT_memory_object) {
2197      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
2198      return;
2199   }
2200
2201   d = find_value(func, pname, &p, &v);
2202   size = get_value_size(d->type, &v);
2203   if (size <= 0) {
2204      _mesa_problem(ctx, "invalid value type in GetUnsignedBytevEXT()");
2205   }
2206
2207   switch (d->type) {
2208   case TYPE_BIT_0:
2209   case TYPE_BIT_1:
2210   case TYPE_BIT_2:
2211   case TYPE_BIT_3:
2212   case TYPE_BIT_4:
2213   case TYPE_BIT_5:
2214   case TYPE_BIT_6:
2215   case TYPE_BIT_7:
2216      shift = d->type - TYPE_BIT_0;
2217      data[0] = (*(GLbitfield *) p >> shift) & 1;
2218      break;
2219   case TYPE_CONST:
2220      memcpy(data, &d->offset, size);
2221      break;
2222   case TYPE_INT_N:
2223      memcpy(data, &v.value_int_n.ints, size);
2224      break;
2225   case TYPE_UINT:
2226   case TYPE_INT:
2227   case TYPE_INT_2:
2228   case TYPE_UINT_2:
2229   case TYPE_INT_3:
2230   case TYPE_UINT_3:
2231   case TYPE_INT_4:
2232   case TYPE_UINT_4:
2233   case TYPE_INT64:
2234   case TYPE_ENUM:
2235   case TYPE_ENUM_2:
2236   case TYPE_BOOLEAN:
2237   case TYPE_UBYTE:
2238   case TYPE_SHORT:
2239   case TYPE_FLOAT:
2240   case TYPE_FLOATN:
2241   case TYPE_FLOAT_2:
2242   case TYPE_FLOATN_2:
2243   case TYPE_FLOAT_3:
2244   case TYPE_FLOATN_3:
2245   case TYPE_FLOAT_4:
2246   case TYPE_FLOATN_4:
2247   case TYPE_FLOAT_8:
2248   case TYPE_DOUBLEN:
2249   case TYPE_DOUBLEN_2:
2250   case TYPE_MATRIX:
2251   case TYPE_MATRIX_T:
2252      memcpy(data, p, size);
2253      break;
2254   case TYPE_ENUM16: {
2255      GLenum e = *(GLenum16 *)p;
2256      memcpy(data, &e, sizeof(e));
2257      break;
2258   }
2259   default:
2260      break; /* nothing - GL error was recorded */
2261   }
2262}
2263
2264/**
2265 * Convert a GL texture binding enum such as GL_TEXTURE_BINDING_2D
2266 * into the corresponding Mesa texture target index.
2267 * \return TEXTURE_x_INDEX or -1 if binding is invalid
2268 */
2269static int
2270tex_binding_to_index(const struct gl_context *ctx, GLenum binding)
2271{
2272   switch (binding) {
2273   case GL_TEXTURE_BINDING_1D:
2274      return _mesa_is_desktop_gl(ctx) ? TEXTURE_1D_INDEX : -1;
2275   case GL_TEXTURE_BINDING_2D:
2276      return TEXTURE_2D_INDEX;
2277   case GL_TEXTURE_BINDING_3D:
2278      return ctx->API != API_OPENGLES ? TEXTURE_3D_INDEX : -1;
2279   case GL_TEXTURE_BINDING_CUBE_MAP:
2280      return ctx->Extensions.ARB_texture_cube_map
2281         ? TEXTURE_CUBE_INDEX : -1;
2282   case GL_TEXTURE_BINDING_RECTANGLE:
2283      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.NV_texture_rectangle
2284         ? TEXTURE_RECT_INDEX : -1;
2285   case GL_TEXTURE_BINDING_1D_ARRAY:
2286      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_array
2287         ? TEXTURE_1D_ARRAY_INDEX : -1;
2288   case GL_TEXTURE_BINDING_2D_ARRAY:
2289      return (_mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_array)
2290         || _mesa_is_gles3(ctx)
2291         ? TEXTURE_2D_ARRAY_INDEX : -1;
2292   case GL_TEXTURE_BINDING_BUFFER:
2293      return (_mesa_has_ARB_texture_buffer_object(ctx) ||
2294              _mesa_has_OES_texture_buffer(ctx)) ?
2295             TEXTURE_BUFFER_INDEX : -1;
2296   case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2297      return _mesa_has_texture_cube_map_array(ctx)
2298         ? TEXTURE_CUBE_ARRAY_INDEX : -1;
2299   case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2300      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_multisample
2301         ? TEXTURE_2D_MULTISAMPLE_INDEX : -1;
2302   case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2303      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_multisample
2304         ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : -1;
2305   default:
2306      return -1;
2307   }
2308}
2309
2310static enum value_type
2311find_value_indexed(const char *func, GLenum pname, GLuint index, union value *v)
2312{
2313   GET_CURRENT_CONTEXT(ctx);
2314
2315   switch (pname) {
2316
2317   case GL_BLEND:
2318      if (index >= ctx->Const.MaxDrawBuffers)
2319         goto invalid_value;
2320      if (!ctx->Extensions.EXT_draw_buffers2)
2321         goto invalid_enum;
2322      v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
2323      return TYPE_INT;
2324
2325   case GL_BLEND_SRC:
2326      /* fall-through */
2327   case GL_BLEND_SRC_RGB:
2328      if (index >= ctx->Const.MaxDrawBuffers)
2329         goto invalid_value;
2330      if (!ctx->Extensions.ARB_draw_buffers_blend)
2331         goto invalid_enum;
2332      v->value_int = ctx->Color.Blend[index].SrcRGB;
2333      return TYPE_INT;
2334   case GL_BLEND_SRC_ALPHA:
2335      if (index >= ctx->Const.MaxDrawBuffers)
2336         goto invalid_value;
2337      if (!ctx->Extensions.ARB_draw_buffers_blend)
2338         goto invalid_enum;
2339      v->value_int = ctx->Color.Blend[index].SrcA;
2340      return TYPE_INT;
2341   case GL_BLEND_DST:
2342      /* fall-through */
2343   case GL_BLEND_DST_RGB:
2344      if (index >= ctx->Const.MaxDrawBuffers)
2345         goto invalid_value;
2346      if (!ctx->Extensions.ARB_draw_buffers_blend)
2347         goto invalid_enum;
2348      v->value_int = ctx->Color.Blend[index].DstRGB;
2349      return TYPE_INT;
2350   case GL_BLEND_DST_ALPHA:
2351      if (index >= ctx->Const.MaxDrawBuffers)
2352         goto invalid_value;
2353      if (!ctx->Extensions.ARB_draw_buffers_blend)
2354         goto invalid_enum;
2355      v->value_int = ctx->Color.Blend[index].DstA;
2356      return TYPE_INT;
2357   case GL_BLEND_EQUATION_RGB:
2358      if (index >= ctx->Const.MaxDrawBuffers)
2359         goto invalid_value;
2360      if (!ctx->Extensions.ARB_draw_buffers_blend)
2361         goto invalid_enum;
2362      v->value_int = ctx->Color.Blend[index].EquationRGB;
2363      return TYPE_INT;
2364   case GL_BLEND_EQUATION_ALPHA:
2365      if (index >= ctx->Const.MaxDrawBuffers)
2366         goto invalid_value;
2367      if (!ctx->Extensions.ARB_draw_buffers_blend)
2368         goto invalid_enum;
2369      v->value_int = ctx->Color.Blend[index].EquationA;
2370      return TYPE_INT;
2371
2372   case GL_COLOR_WRITEMASK:
2373      if (index >= ctx->Const.MaxDrawBuffers)
2374         goto invalid_value;
2375      if (!ctx->Extensions.EXT_draw_buffers2)
2376         goto invalid_enum;
2377      v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 0);
2378      v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 1);
2379      v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 2);
2380      v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 3);
2381      return TYPE_INT_4;
2382
2383   case GL_SCISSOR_BOX:
2384      if (index >= ctx->Const.MaxViewports)
2385         goto invalid_value;
2386      v->value_int_4[0] = ctx->Scissor.ScissorArray[index].X;
2387      v->value_int_4[1] = ctx->Scissor.ScissorArray[index].Y;
2388      v->value_int_4[2] = ctx->Scissor.ScissorArray[index].Width;
2389      v->value_int_4[3] = ctx->Scissor.ScissorArray[index].Height;
2390      return TYPE_INT_4;
2391
2392   case GL_WINDOW_RECTANGLE_EXT:
2393      if (!ctx->Extensions.EXT_window_rectangles)
2394         goto invalid_enum;
2395      if (index >= ctx->Const.MaxWindowRectangles)
2396         goto invalid_value;
2397      v->value_int_4[0] = ctx->Scissor.WindowRects[index].X;
2398      v->value_int_4[1] = ctx->Scissor.WindowRects[index].Y;
2399      v->value_int_4[2] = ctx->Scissor.WindowRects[index].Width;
2400      v->value_int_4[3] = ctx->Scissor.WindowRects[index].Height;
2401      return TYPE_INT_4;
2402
2403   case GL_VIEWPORT:
2404      if (index >= ctx->Const.MaxViewports)
2405         goto invalid_value;
2406      v->value_float_4[0] = ctx->ViewportArray[index].X;
2407      v->value_float_4[1] = ctx->ViewportArray[index].Y;
2408      v->value_float_4[2] = ctx->ViewportArray[index].Width;
2409      v->value_float_4[3] = ctx->ViewportArray[index].Height;
2410      return TYPE_FLOAT_4;
2411
2412   case GL_DEPTH_RANGE:
2413      if (index >= ctx->Const.MaxViewports)
2414         goto invalid_value;
2415      v->value_double_2[0] = ctx->ViewportArray[index].Near;
2416      v->value_double_2[1] = ctx->ViewportArray[index].Far;
2417      return TYPE_DOUBLEN_2;
2418
2419   case GL_TRANSFORM_FEEDBACK_BUFFER_START:
2420      if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2421         goto invalid_value;
2422      if (!ctx->Extensions.EXT_transform_feedback)
2423         goto invalid_enum;
2424      v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
2425      return TYPE_INT64;
2426
2427   case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
2428      if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2429         goto invalid_value;
2430      if (!ctx->Extensions.EXT_transform_feedback)
2431         goto invalid_enum;
2432      v->value_int64
2433         = ctx->TransformFeedback.CurrentObject->RequestedSize[index];
2434      return TYPE_INT64;
2435
2436   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2437      if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2438         goto invalid_value;
2439      if (!ctx->Extensions.EXT_transform_feedback)
2440         goto invalid_enum;
2441      v->value_int = ctx->TransformFeedback.CurrentObject->BufferNames[index];
2442      return TYPE_INT;
2443
2444   case GL_UNIFORM_BUFFER_BINDING:
2445      if (index >= ctx->Const.MaxUniformBufferBindings)
2446         goto invalid_value;
2447      if (!ctx->Extensions.ARB_uniform_buffer_object)
2448         goto invalid_enum;
2449      v->value_int = ctx->UniformBufferBindings[index].BufferObject->Name;
2450      return TYPE_INT;
2451
2452   case GL_UNIFORM_BUFFER_START:
2453      if (index >= ctx->Const.MaxUniformBufferBindings)
2454         goto invalid_value;
2455      if (!ctx->Extensions.ARB_uniform_buffer_object)
2456         goto invalid_enum;
2457      v->value_int = ctx->UniformBufferBindings[index].Offset < 0 ? 0 :
2458                     ctx->UniformBufferBindings[index].Offset;
2459      return TYPE_INT;
2460
2461   case GL_UNIFORM_BUFFER_SIZE:
2462      if (index >= ctx->Const.MaxUniformBufferBindings)
2463         goto invalid_value;
2464      if (!ctx->Extensions.ARB_uniform_buffer_object)
2465         goto invalid_enum;
2466      v->value_int = ctx->UniformBufferBindings[index].Size < 0 ? 0 :
2467                     ctx->UniformBufferBindings[index].Size;
2468      return TYPE_INT;
2469
2470   /* ARB_shader_storage_buffer_object */
2471   case GL_SHADER_STORAGE_BUFFER_BINDING:
2472      if (!ctx->Extensions.ARB_shader_storage_buffer_object)
2473         goto invalid_enum;
2474      if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2475         goto invalid_value;
2476      v->value_int = ctx->ShaderStorageBufferBindings[index].BufferObject->Name;
2477      return TYPE_INT;
2478
2479   case GL_SHADER_STORAGE_BUFFER_START:
2480      if (!ctx->Extensions.ARB_shader_storage_buffer_object)
2481         goto invalid_enum;
2482      if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2483         goto invalid_value;
2484      v->value_int = ctx->ShaderStorageBufferBindings[index].Offset < 0 ? 0 :
2485                     ctx->ShaderStorageBufferBindings[index].Offset;
2486      return TYPE_INT;
2487
2488   case GL_SHADER_STORAGE_BUFFER_SIZE:
2489      if (!ctx->Extensions.ARB_shader_storage_buffer_object)
2490         goto invalid_enum;
2491      if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2492         goto invalid_value;
2493      v->value_int = ctx->ShaderStorageBufferBindings[index].Size < 0 ? 0 :
2494                     ctx->ShaderStorageBufferBindings[index].Size;
2495      return TYPE_INT;
2496
2497   /* ARB_texture_multisample / GL3.2 */
2498   case GL_SAMPLE_MASK_VALUE:
2499      if (index != 0)
2500         goto invalid_value;
2501      if (!ctx->Extensions.ARB_texture_multisample)
2502         goto invalid_enum;
2503      v->value_int = ctx->Multisample.SampleMaskValue;
2504      return TYPE_INT;
2505
2506   case GL_ATOMIC_COUNTER_BUFFER_BINDING:
2507      if (!ctx->Extensions.ARB_shader_atomic_counters)
2508         goto invalid_enum;
2509      if (index >= ctx->Const.MaxAtomicBufferBindings)
2510         goto invalid_value;
2511      v->value_int = ctx->AtomicBufferBindings[index].BufferObject->Name;
2512      return TYPE_INT;
2513
2514   case GL_ATOMIC_COUNTER_BUFFER_START:
2515      if (!ctx->Extensions.ARB_shader_atomic_counters)
2516         goto invalid_enum;
2517      if (index >= ctx->Const.MaxAtomicBufferBindings)
2518         goto invalid_value;
2519      v->value_int64 = ctx->AtomicBufferBindings[index].Offset < 0 ? 0 :
2520                       ctx->AtomicBufferBindings[index].Offset;
2521      return TYPE_INT64;
2522
2523   case GL_ATOMIC_COUNTER_BUFFER_SIZE:
2524      if (!ctx->Extensions.ARB_shader_atomic_counters)
2525         goto invalid_enum;
2526      if (index >= ctx->Const.MaxAtomicBufferBindings)
2527         goto invalid_value;
2528      v->value_int64 = ctx->AtomicBufferBindings[index].Size < 0 ? 0 :
2529                       ctx->AtomicBufferBindings[index].Size;
2530      return TYPE_INT64;
2531
2532   case GL_VERTEX_BINDING_DIVISOR:
2533      if ((!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_instanced_arrays) &&
2534          !_mesa_is_gles31(ctx))
2535          goto invalid_enum;
2536      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2537          goto invalid_value;
2538      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor;
2539      return TYPE_INT;
2540
2541   case GL_VERTEX_BINDING_OFFSET:
2542      if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles31(ctx))
2543          goto invalid_enum;
2544      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2545          goto invalid_value;
2546      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
2547      return TYPE_INT;
2548
2549   case GL_VERTEX_BINDING_STRIDE:
2550      if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles31(ctx))
2551          goto invalid_enum;
2552      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2553          goto invalid_value;
2554      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].Stride;
2555      return TYPE_INT;
2556
2557   case GL_VERTEX_BINDING_BUFFER:
2558      if (ctx->API == API_OPENGLES2 && ctx->Version < 31)
2559         goto invalid_enum;
2560      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2561         goto invalid_value;
2562      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name;
2563      return TYPE_INT;
2564
2565   /* ARB_shader_image_load_store */
2566   case GL_IMAGE_BINDING_NAME: {
2567      struct gl_texture_object *t;
2568
2569      if (!ctx->Extensions.ARB_shader_image_load_store)
2570         goto invalid_enum;
2571      if (index >= ctx->Const.MaxImageUnits)
2572         goto invalid_value;
2573
2574      t = ctx->ImageUnits[index].TexObj;
2575      v->value_int = (t ? t->Name : 0);
2576      return TYPE_INT;
2577   }
2578
2579   case GL_IMAGE_BINDING_LEVEL:
2580      if (!ctx->Extensions.ARB_shader_image_load_store)
2581         goto invalid_enum;
2582      if (index >= ctx->Const.MaxImageUnits)
2583         goto invalid_value;
2584
2585      v->value_int = ctx->ImageUnits[index].Level;
2586      return TYPE_INT;
2587
2588   case GL_IMAGE_BINDING_LAYERED:
2589      if (!ctx->Extensions.ARB_shader_image_load_store)
2590         goto invalid_enum;
2591      if (index >= ctx->Const.MaxImageUnits)
2592         goto invalid_value;
2593
2594      v->value_int = ctx->ImageUnits[index].Layered;
2595      return TYPE_INT;
2596
2597   case GL_IMAGE_BINDING_LAYER:
2598      if (!ctx->Extensions.ARB_shader_image_load_store)
2599         goto invalid_enum;
2600      if (index >= ctx->Const.MaxImageUnits)
2601         goto invalid_value;
2602
2603      v->value_int = ctx->ImageUnits[index].Layer;
2604      return TYPE_INT;
2605
2606   case GL_IMAGE_BINDING_ACCESS:
2607      if (!ctx->Extensions.ARB_shader_image_load_store)
2608         goto invalid_enum;
2609      if (index >= ctx->Const.MaxImageUnits)
2610         goto invalid_value;
2611
2612      v->value_int = ctx->ImageUnits[index].Access;
2613      return TYPE_INT;
2614
2615   case GL_IMAGE_BINDING_FORMAT:
2616      if (!ctx->Extensions.ARB_shader_image_load_store)
2617         goto invalid_enum;
2618      if (index >= ctx->Const.MaxImageUnits)
2619         goto invalid_value;
2620
2621      v->value_int = ctx->ImageUnits[index].Format;
2622      return TYPE_INT;
2623
2624   /* ARB_direct_state_access */
2625   case GL_TEXTURE_BINDING_1D:
2626   case GL_TEXTURE_BINDING_1D_ARRAY:
2627   case GL_TEXTURE_BINDING_2D:
2628   case GL_TEXTURE_BINDING_2D_ARRAY:
2629   case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2630   case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2631   case GL_TEXTURE_BINDING_3D:
2632   case GL_TEXTURE_BINDING_BUFFER:
2633   case GL_TEXTURE_BINDING_CUBE_MAP:
2634   case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2635   case GL_TEXTURE_BINDING_RECTANGLE: {
2636      int target;
2637
2638      if (ctx->API != API_OPENGL_CORE)
2639         goto invalid_enum;
2640      target = tex_binding_to_index(ctx, pname);
2641      if (target < 0)
2642         goto invalid_enum;
2643      if (index >= _mesa_max_tex_unit(ctx))
2644         goto invalid_value;
2645
2646      v->value_int = ctx->Texture.Unit[index].CurrentTex[target]->Name;
2647      return TYPE_INT;
2648   }
2649
2650   case GL_SAMPLER_BINDING: {
2651      struct gl_sampler_object *samp;
2652
2653      if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 33)
2654         goto invalid_enum;
2655      if (index >= _mesa_max_tex_unit(ctx))
2656         goto invalid_value;
2657
2658      samp = ctx->Texture.Unit[index].Sampler;
2659      v->value_int = samp ? samp->Name : 0;
2660      return TYPE_INT;
2661   }
2662
2663   case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
2664      if (!_mesa_has_compute_shaders(ctx))
2665         goto invalid_enum;
2666      if (index >= 3)
2667         goto invalid_value;
2668      v->value_int = ctx->Const.MaxComputeWorkGroupCount[index];
2669      return TYPE_INT;
2670
2671   case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
2672      if (!_mesa_has_compute_shaders(ctx))
2673         goto invalid_enum;
2674      if (index >= 3)
2675         goto invalid_value;
2676      v->value_int = ctx->Const.MaxComputeWorkGroupSize[index];
2677      return TYPE_INT;
2678
2679   /* ARB_compute_variable_group_size */
2680   case GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB:
2681      if (!ctx->Extensions.ARB_compute_variable_group_size)
2682         goto invalid_enum;
2683      if (index >= 3)
2684         goto invalid_value;
2685      v->value_int = ctx->Const.MaxComputeVariableGroupSize[index];
2686      return TYPE_INT;
2687
2688   /* GL_EXT_external_objects */
2689   case GL_NUM_DEVICE_UUIDS_EXT:
2690      v->value_int = 1;
2691      return TYPE_INT;
2692   case GL_DRIVER_UUID_EXT:
2693      if (index >= 1)
2694         goto invalid_value;
2695      _mesa_get_driver_uuid(ctx, v->value_int_4);
2696      return TYPE_INT_4;
2697   case GL_DEVICE_UUID_EXT:
2698      if (index >= 1)
2699         goto invalid_value;
2700      _mesa_get_device_uuid(ctx, v->value_int_4);
2701      return TYPE_INT_4;
2702   }
2703
2704 invalid_enum:
2705   _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
2706               _mesa_enum_to_string(pname));
2707   return TYPE_INVALID;
2708 invalid_value:
2709   _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
2710               _mesa_enum_to_string(pname));
2711   return TYPE_INVALID;
2712}
2713
2714void GLAPIENTRY
2715_mesa_GetBooleani_v( GLenum pname, GLuint index, GLboolean *params )
2716{
2717   union value v;
2718   enum value_type type =
2719      find_value_indexed("glGetBooleani_v", pname, index, &v);
2720
2721   switch (type) {
2722   case TYPE_INT:
2723   case TYPE_UINT:
2724      params[0] = INT_TO_BOOLEAN(v.value_int);
2725      break;
2726   case TYPE_INT_4:
2727   case TYPE_UINT_4:
2728      params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
2729      params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
2730      params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
2731      params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
2732      break;
2733   case TYPE_INT64:
2734      params[0] = INT64_TO_BOOLEAN(v.value_int64);
2735      break;
2736   default:
2737      ; /* nothing - GL error was recorded */
2738   }
2739}
2740
2741void GLAPIENTRY
2742_mesa_GetIntegeri_v( GLenum pname, GLuint index, GLint *params )
2743{
2744   union value v;
2745   enum value_type type =
2746      find_value_indexed("glGetIntegeri_v", pname, index, &v);
2747
2748   switch (type) {
2749   case TYPE_FLOAT_4:
2750   case TYPE_FLOATN_4:
2751      params[3] = IROUND(v.value_float_4[3]);
2752   case TYPE_FLOAT_3:
2753   case TYPE_FLOATN_3:
2754      params[2] = IROUND(v.value_float_4[2]);
2755   case TYPE_FLOAT_2:
2756   case TYPE_FLOATN_2:
2757      params[1] = IROUND(v.value_float_4[1]);
2758   case TYPE_FLOAT:
2759   case TYPE_FLOATN:
2760      params[0] = IROUND(v.value_float_4[0]);
2761      break;
2762
2763   case TYPE_DOUBLEN_2:
2764      params[1] = IROUND(v.value_double_2[1]);
2765   case TYPE_DOUBLEN:
2766      params[0] = IROUND(v.value_double_2[0]);
2767      break;
2768
2769   case TYPE_INT:
2770   case TYPE_UINT:
2771      params[0] = v.value_int;
2772      break;
2773   case TYPE_INT_4:
2774   case TYPE_UINT_4:
2775      params[0] = v.value_int_4[0];
2776      params[1] = v.value_int_4[1];
2777      params[2] = v.value_int_4[2];
2778      params[3] = v.value_int_4[3];
2779      break;
2780   case TYPE_INT64:
2781      params[0] = INT64_TO_INT(v.value_int64);
2782      break;
2783   default:
2784      ; /* nothing - GL error was recorded */
2785   }
2786}
2787
2788void GLAPIENTRY
2789_mesa_GetInteger64i_v( GLenum pname, GLuint index, GLint64 *params )
2790{
2791   union value v;
2792   enum value_type type =
2793      find_value_indexed("glGetInteger64i_v", pname, index, &v);
2794
2795   switch (type) {
2796   case TYPE_INT:
2797      params[0] = v.value_int;
2798      break;
2799   case TYPE_INT_4:
2800      params[0] = v.value_int_4[0];
2801      params[1] = v.value_int_4[1];
2802      params[2] = v.value_int_4[2];
2803      params[3] = v.value_int_4[3];
2804      break;
2805   case TYPE_UINT:
2806      params[0] = (GLuint) v.value_int;
2807      break;
2808   case TYPE_UINT_4:
2809      params[0] = (GLuint) v.value_int_4[0];
2810      params[1] = (GLuint) v.value_int_4[1];
2811      params[2] = (GLuint) v.value_int_4[2];
2812      params[3] = (GLuint) v.value_int_4[3];
2813      break;
2814   case TYPE_INT64:
2815      params[0] = v.value_int64;
2816      break;
2817   default:
2818      ; /* nothing - GL error was recorded */
2819   }
2820}
2821
2822void GLAPIENTRY
2823_mesa_GetFloati_v(GLenum pname, GLuint index, GLfloat *params)
2824{
2825   int i;
2826   GLmatrix *m;
2827   union value v;
2828   enum value_type type =
2829      find_value_indexed("glGetFloati_v", pname, index, &v);
2830
2831   switch (type) {
2832   case TYPE_FLOAT_4:
2833   case TYPE_FLOATN_4:
2834      params[3] = v.value_float_4[3];
2835   case TYPE_FLOAT_3:
2836   case TYPE_FLOATN_3:
2837      params[2] = v.value_float_4[2];
2838   case TYPE_FLOAT_2:
2839   case TYPE_FLOATN_2:
2840      params[1] = v.value_float_4[1];
2841   case TYPE_FLOAT:
2842   case TYPE_FLOATN:
2843      params[0] = v.value_float_4[0];
2844      break;
2845
2846   case TYPE_DOUBLEN_2:
2847      params[1] = (GLfloat) v.value_double_2[1];
2848   case TYPE_DOUBLEN:
2849      params[0] = (GLfloat) v.value_double_2[0];
2850      break;
2851
2852   case TYPE_INT_4:
2853      params[3] = (GLfloat) v.value_int_4[3];
2854   case TYPE_INT_3:
2855      params[2] = (GLfloat) v.value_int_4[2];
2856   case TYPE_INT_2:
2857   case TYPE_ENUM_2:
2858      params[1] = (GLfloat) v.value_int_4[1];
2859   case TYPE_INT:
2860   case TYPE_ENUM:
2861   case TYPE_ENUM16:
2862      params[0] = (GLfloat) v.value_int_4[0];
2863      break;
2864
2865   case TYPE_INT_N:
2866      for (i = 0; i < v.value_int_n.n; i++)
2867         params[i] = (GLfloat) v.value_int_n.ints[i];
2868      break;
2869
2870   case TYPE_UINT_4:
2871      params[3] = (GLfloat) ((GLuint) v.value_int_4[3]);
2872   case TYPE_UINT_3:
2873      params[2] = (GLfloat) ((GLuint) v.value_int_4[2]);
2874   case TYPE_UINT_2:
2875      params[1] = (GLfloat) ((GLuint) v.value_int_4[1]);
2876   case TYPE_UINT:
2877      params[0] = (GLfloat) ((GLuint) v.value_int_4[0]);
2878      break;
2879
2880   case TYPE_INT64:
2881      params[0] = (GLfloat) v.value_int64;
2882      break;
2883
2884   case TYPE_BOOLEAN:
2885      params[0] = BOOLEAN_TO_FLOAT(v.value_bool);
2886      break;
2887
2888   case TYPE_UBYTE:
2889      params[0] = (GLfloat) v.value_ubyte;
2890      break;
2891
2892   case TYPE_SHORT:
2893      params[0] = (GLfloat) v.value_short;
2894      break;
2895
2896   case TYPE_MATRIX:
2897      m = *(GLmatrix **) &v;
2898      for (i = 0; i < 16; i++)
2899         params[i] = m->m[i];
2900      break;
2901
2902   case TYPE_MATRIX_T:
2903      m = *(GLmatrix **) &v;
2904      for (i = 0; i < 16; i++)
2905         params[i] = m->m[transpose[i]];
2906      break;
2907
2908   default:
2909      ;
2910   }
2911}
2912
2913void GLAPIENTRY
2914_mesa_GetDoublei_v(GLenum pname, GLuint index, GLdouble *params)
2915{
2916   int i;
2917   GLmatrix *m;
2918   union value v;
2919   enum value_type type =
2920      find_value_indexed("glGetDoublei_v", pname, index, &v);
2921
2922   switch (type) {
2923   case TYPE_FLOAT_4:
2924   case TYPE_FLOATN_4:
2925      params[3] = (GLdouble) v.value_float_4[3];
2926   case TYPE_FLOAT_3:
2927   case TYPE_FLOATN_3:
2928      params[2] = (GLdouble) v.value_float_4[2];
2929   case TYPE_FLOAT_2:
2930   case TYPE_FLOATN_2:
2931      params[1] = (GLdouble) v.value_float_4[1];
2932   case TYPE_FLOAT:
2933   case TYPE_FLOATN:
2934      params[0] = (GLdouble) v.value_float_4[0];
2935      break;
2936
2937   case TYPE_DOUBLEN_2:
2938      params[1] = v.value_double_2[1];
2939   case TYPE_DOUBLEN:
2940      params[0] = v.value_double_2[0];
2941      break;
2942
2943   case TYPE_INT_4:
2944      params[3] = (GLdouble) v.value_int_4[3];
2945   case TYPE_INT_3:
2946      params[2] = (GLdouble) v.value_int_4[2];
2947   case TYPE_INT_2:
2948   case TYPE_ENUM_2:
2949      params[1] = (GLdouble) v.value_int_4[1];
2950   case TYPE_INT:
2951   case TYPE_ENUM:
2952   case TYPE_ENUM16:
2953      params[0] = (GLdouble) v.value_int_4[0];
2954      break;
2955
2956   case TYPE_INT_N:
2957      for (i = 0; i < v.value_int_n.n; i++)
2958         params[i] = (GLdouble) v.value_int_n.ints[i];
2959      break;
2960
2961   case TYPE_UINT_4:
2962      params[3] = (GLdouble) ((GLuint) v.value_int_4[3]);
2963   case TYPE_UINT_3:
2964      params[2] = (GLdouble) ((GLuint) v.value_int_4[2]);
2965   case TYPE_UINT_2:
2966      params[1] = (GLdouble) ((GLuint) v.value_int_4[1]);
2967   case TYPE_UINT:
2968      params[0] = (GLdouble) ((GLuint) v.value_int_4[0]);
2969      break;
2970
2971   case TYPE_INT64:
2972      params[0] = (GLdouble) v.value_int64;
2973      break;
2974
2975   case TYPE_BOOLEAN:
2976      params[0] = (GLdouble) BOOLEAN_TO_FLOAT(v.value_bool);
2977      break;
2978
2979   case TYPE_UBYTE:
2980      params[0] = (GLdouble) v.value_ubyte;
2981      break;
2982
2983   case TYPE_SHORT:
2984      params[0] = (GLdouble) v.value_short;
2985      break;
2986
2987   case TYPE_MATRIX:
2988      m = *(GLmatrix **) &v;
2989      for (i = 0; i < 16; i++)
2990         params[i] = (GLdouble) m->m[i];
2991      break;
2992
2993   case TYPE_MATRIX_T:
2994      m = *(GLmatrix **) &v;
2995      for (i = 0; i < 16; i++)
2996         params[i] = (GLdouble) m->m[transpose[i]];
2997      break;
2998
2999   default:
3000      ;
3001   }
3002}
3003
3004void GLAPIENTRY
3005_mesa_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
3006{
3007   GLsizei size;
3008   union value v;
3009   enum value_type type;
3010   const char *func = "glGetUnsignedBytei_vEXT";
3011
3012   GET_CURRENT_CONTEXT(ctx);
3013
3014   if (!ctx->Extensions.EXT_memory_object) {
3015      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
3016      return;
3017   }
3018
3019   type = find_value_indexed(func, target, index, &v);
3020   size = get_value_size(type, &v);
3021   if (size <= 0) {
3022      _mesa_problem(ctx, "invalid value type in GetUnsignedBytei_vEXT()");
3023   }
3024
3025   switch (type) {
3026   case TYPE_UINT:
3027   case TYPE_INT:
3028   case TYPE_INT_2:
3029   case TYPE_UINT_2:
3030   case TYPE_INT_3:
3031   case TYPE_UINT_3:
3032   case TYPE_INT_4:
3033   case TYPE_UINT_4:
3034   case TYPE_INT64:
3035   case TYPE_ENUM16:
3036   case TYPE_ENUM:
3037   case TYPE_ENUM_2:
3038   case TYPE_BOOLEAN:
3039   case TYPE_UBYTE:
3040   case TYPE_SHORT:
3041   case TYPE_FLOAT:
3042   case TYPE_FLOATN:
3043   case TYPE_FLOAT_2:
3044   case TYPE_FLOATN_2:
3045   case TYPE_FLOAT_3:
3046   case TYPE_FLOATN_3:
3047   case TYPE_FLOAT_4:
3048   case TYPE_FLOATN_4:
3049   case TYPE_FLOAT_8:
3050   case TYPE_DOUBLEN:
3051   case TYPE_DOUBLEN_2:
3052   case TYPE_MATRIX:
3053   case TYPE_MATRIX_T:
3054      memcpy(data, &v.value_int, size);
3055      break;
3056   case TYPE_INT_N:
3057      memcpy(data, &v.value_int_n.ints, size);
3058      break;
3059   default:
3060      break; /* nothing - GL error was recorded */
3061   }
3062}
3063
3064void GLAPIENTRY
3065_mesa_GetFixedv(GLenum pname, GLfixed *params)
3066{
3067   const struct value_desc *d;
3068   union value v;
3069   GLmatrix *m;
3070   int shift, i;
3071   void *p;
3072
3073   d = find_value("glGetDoublev", pname, &p, &v);
3074   switch (d->type) {
3075   case TYPE_INVALID:
3076      break;
3077   case TYPE_CONST:
3078      params[0] = INT_TO_FIXED(d->offset);
3079      break;
3080
3081   case TYPE_FLOAT_4:
3082   case TYPE_FLOATN_4:
3083      params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
3084   case TYPE_FLOAT_3:
3085   case TYPE_FLOATN_3:
3086      params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
3087   case TYPE_FLOAT_2:
3088   case TYPE_FLOATN_2:
3089      params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
3090   case TYPE_FLOAT:
3091   case TYPE_FLOATN:
3092      params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
3093      break;
3094
3095   case TYPE_DOUBLEN_2:
3096      params[1] = FLOAT_TO_FIXED(((GLdouble *) p)[1]);
3097   case TYPE_DOUBLEN:
3098      params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
3099      break;
3100
3101   case TYPE_INT_4:
3102   case TYPE_UINT_4:
3103      params[3] = INT_TO_FIXED(((GLint *) p)[3]);
3104   case TYPE_INT_3:
3105   case TYPE_UINT_3:
3106      params[2] = INT_TO_FIXED(((GLint *) p)[2]);
3107   case TYPE_INT_2:
3108   case TYPE_UINT_2:
3109   case TYPE_ENUM_2:
3110      params[1] = INT_TO_FIXED(((GLint *) p)[1]);
3111   case TYPE_INT:
3112   case TYPE_UINT:
3113   case TYPE_ENUM:
3114      params[0] = INT_TO_FIXED(((GLint *) p)[0]);
3115      break;
3116
3117   case TYPE_ENUM16:
3118      params[0] = INT_TO_FIXED((GLint)(((GLenum16 *) p)[0]));
3119      break;
3120
3121   case TYPE_INT_N:
3122      for (i = 0; i < v.value_int_n.n; i++)
3123         params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
3124      break;
3125
3126   case TYPE_INT64:
3127      params[0] = ((GLint64 *) p)[0];
3128      break;
3129
3130   case TYPE_BOOLEAN:
3131      params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
3132      break;
3133
3134   case TYPE_UBYTE:
3135      params[0] = INT_TO_FIXED(((GLubyte *) p)[0]);
3136      break;
3137
3138   case TYPE_SHORT:
3139      params[0] = INT_TO_FIXED(((GLshort *) p)[0]);
3140      break;
3141
3142   case TYPE_MATRIX:
3143      m = *(GLmatrix **) p;
3144      for (i = 0; i < 16; i++)
3145         params[i] = FLOAT_TO_FIXED(m->m[i]);
3146      break;
3147
3148   case TYPE_MATRIX_T:
3149      m = *(GLmatrix **) p;
3150      for (i = 0; i < 16; i++)
3151         params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
3152      break;
3153
3154   case TYPE_BIT_0:
3155   case TYPE_BIT_1:
3156   case TYPE_BIT_2:
3157   case TYPE_BIT_3:
3158   case TYPE_BIT_4:
3159   case TYPE_BIT_5:
3160   case TYPE_BIT_6:
3161   case TYPE_BIT_7:
3162      shift = d->type - TYPE_BIT_0;
3163      params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);
3164      break;
3165   }
3166}
3167