get.c revision 01e04c3f 
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_DRIVER_UUID_EXT:
874      _mesa_get_driver_uuid(ctx, v->value_int_4);
875      break;
876   case GL_DEVICE_UUID_EXT:
877      _mesa_get_device_uuid(ctx, v->value_int_4);
878      break;
879
880   /* GL_EXT_packed_float */
881   case GL_RGBA_SIGNED_COMPONENTS_EXT:
882      {
883         /* Note: we only check the 0th color attachment. */
884         const struct gl_renderbuffer *rb =
885            ctx->DrawBuffer->_ColorDrawBuffers[0];
886         if (rb && _mesa_is_format_signed(rb->Format)) {
887            /* Issue 17 of GL_EXT_packed_float:  If a component (such as
888             * alpha) has zero bits, the component should not be considered
889             * signed and so the bit for the respective component should be
890             * zeroed.
891             */
892            GLint r_bits =
893               _mesa_get_format_bits(rb->Format, GL_RED_BITS);
894            GLint g_bits =
895               _mesa_get_format_bits(rb->Format, GL_GREEN_BITS);
896            GLint b_bits =
897               _mesa_get_format_bits(rb->Format, GL_BLUE_BITS);
898            GLint a_bits =
899               _mesa_get_format_bits(rb->Format, GL_ALPHA_BITS);
900            GLint l_bits =
901               _mesa_get_format_bits(rb->Format, GL_TEXTURE_LUMINANCE_SIZE);
902            GLint i_bits =
903               _mesa_get_format_bits(rb->Format, GL_TEXTURE_INTENSITY_SIZE);
904
905            v->value_int_4[0] = r_bits + l_bits + i_bits > 0;
906            v->value_int_4[1] = g_bits + l_bits + i_bits > 0;
907            v->value_int_4[2] = b_bits + l_bits + i_bits > 0;
908            v->value_int_4[3] = a_bits + i_bits > 0;
909         }
910         else {
911            v->value_int_4[0] =
912            v->value_int_4[1] =
913            v->value_int_4[2] =
914            v->value_int_4[3] = 0;
915         }
916      }
917      break;
918
919   /* GL_ARB_vertex_buffer_object */
920   case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
921   case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
922   case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
923   case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
924   case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
925   case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
926   case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
927      buffer_obj = (struct gl_buffer_object **)
928         ((char *) ctx->Array.VAO + d->offset);
929      v->value_int = (*buffer_obj)->Name;
930      break;
931   case GL_ARRAY_BUFFER_BINDING_ARB:
932      v->value_int = ctx->Array.ArrayBufferObj->Name;
933      break;
934   case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
935      v->value_int =
936         ctx->Array.VAO->BufferBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name;
937      break;
938   case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
939      v->value_int = ctx->Array.VAO->IndexBufferObj->Name;
940      break;
941
942   /* ARB_vertex_array_bgra */
943   case GL_COLOR_ARRAY_SIZE:
944      array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0];
945      v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size;
946      break;
947   case GL_SECONDARY_COLOR_ARRAY_SIZE:
948      array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1];
949      v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size;
950      break;
951
952   /* ARB_copy_buffer */
953   case GL_COPY_READ_BUFFER:
954      v->value_int = ctx->CopyReadBuffer->Name;
955      break;
956   case GL_COPY_WRITE_BUFFER:
957      v->value_int = ctx->CopyWriteBuffer->Name;
958      break;
959
960   case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
961      v->value_int = ctx->Pack.BufferObj->Name;
962      break;
963   case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
964      v->value_int = ctx->Unpack.BufferObj->Name;
965      break;
966   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
967      v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
968      break;
969   case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
970      v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
971      break;
972   case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
973      v->value_int = ctx->TransformFeedback.CurrentObject->Active;
974      break;
975   case GL_TRANSFORM_FEEDBACK_BINDING:
976      v->value_int = ctx->TransformFeedback.CurrentObject->Name;
977      break;
978   case GL_CURRENT_PROGRAM:
979      /* The Changelog of the ARB_separate_shader_objects spec says:
980       *
981       * 24 25 Jul 2011  pbrown  Remove the language erroneously deleting
982       *                         CURRENT_PROGRAM.  In the EXT extension, this
983       *                         token was aliased to ACTIVE_PROGRAM_EXT, and
984       *                         was used to indicate the last program set by
985       *                         either ActiveProgramEXT or UseProgram.  In
986       *                         the ARB extension, the SSO active programs
987       *                         are now program pipeline object state and
988       *                         CURRENT_PROGRAM should still be used to query
989       *                         the last program set by UseProgram (bug 7822).
990       */
991      v->value_int =
992         ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
993      break;
994   case GL_READ_FRAMEBUFFER_BINDING_EXT:
995      v->value_int = ctx->ReadBuffer->Name;
996      break;
997   case GL_RENDERBUFFER_BINDING_EXT:
998      v->value_int =
999         ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
1000      break;
1001   case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
1002      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_POINT_SIZE].BufferObj->Name;
1003      break;
1004
1005   case GL_FOG_COLOR:
1006      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1007         COPY_4FV(v->value_float_4, ctx->Fog.Color);
1008      else
1009         COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped);
1010      break;
1011   case GL_COLOR_CLEAR_VALUE:
1012      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer)) {
1013         v->value_float_4[0] = CLAMP(ctx->Color.ClearColor.f[0], 0.0F, 1.0F);
1014         v->value_float_4[1] = CLAMP(ctx->Color.ClearColor.f[1], 0.0F, 1.0F);
1015         v->value_float_4[2] = CLAMP(ctx->Color.ClearColor.f[2], 0.0F, 1.0F);
1016         v->value_float_4[3] = CLAMP(ctx->Color.ClearColor.f[3], 0.0F, 1.0F);
1017      } else
1018         COPY_4FV(v->value_float_4, ctx->Color.ClearColor.f);
1019      break;
1020   case GL_BLEND_COLOR_EXT:
1021      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1022         COPY_4FV(v->value_float_4, ctx->Color.BlendColor);
1023      else
1024         COPY_4FV(v->value_float_4, ctx->Color.BlendColorUnclamped);
1025      break;
1026   case GL_ALPHA_TEST_REF:
1027      if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1028         v->value_float = ctx->Color.AlphaRef;
1029      else
1030         v->value_float = ctx->Color.AlphaRefUnclamped;
1031      break;
1032   case GL_MAX_VERTEX_UNIFORM_VECTORS:
1033      v->value_int = ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents / 4;
1034      break;
1035
1036   case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1037      v->value_int = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents / 4;
1038      break;
1039
1040   /* GL_ARB_texture_buffer_object */
1041   case GL_TEXTURE_BUFFER_ARB:
1042      v->value_int = ctx->Texture.BufferObject->Name;
1043      break;
1044   case GL_TEXTURE_BINDING_BUFFER_ARB:
1045      unit = ctx->Texture.CurrentUnit;
1046      v->value_int =
1047         ctx->Texture.Unit[unit].CurrentTex[TEXTURE_BUFFER_INDEX]->Name;
1048      break;
1049   case GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB:
1050      {
1051         struct gl_buffer_object *buf =
1052            ctx->Texture.Unit[ctx->Texture.CurrentUnit]
1053            .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObject;
1054         v->value_int = buf ? buf->Name : 0;
1055      }
1056      break;
1057   case GL_TEXTURE_BUFFER_FORMAT_ARB:
1058      v->value_int = ctx->Texture.Unit[ctx->Texture.CurrentUnit]
1059         .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObjectFormat;
1060      break;
1061
1062   /* GL_ARB_sampler_objects */
1063   case GL_SAMPLER_BINDING:
1064      {
1065         struct gl_sampler_object *samp =
1066            ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler;
1067         v->value_int = samp ? samp->Name : 0;
1068      }
1069      break;
1070   /* GL_ARB_uniform_buffer_object */
1071   case GL_UNIFORM_BUFFER_BINDING:
1072      v->value_int = ctx->UniformBuffer->Name;
1073      break;
1074   /* GL_ARB_shader_storage_buffer_object */
1075   case GL_SHADER_STORAGE_BUFFER_BINDING:
1076      v->value_int = ctx->ShaderStorageBuffer->Name;
1077      break;
1078   /* GL_ARB_query_buffer_object */
1079   case GL_QUERY_BUFFER_BINDING:
1080      v->value_int = ctx->QueryBuffer->Name;
1081      break;
1082   /* GL_ARB_timer_query */
1083   case GL_TIMESTAMP:
1084      if (ctx->Driver.GetTimestamp) {
1085         v->value_int64 = ctx->Driver.GetTimestamp(ctx);
1086      }
1087      else {
1088         _mesa_problem(ctx, "driver doesn't implement GetTimestamp");
1089      }
1090      break;
1091   /* GL_KHR_DEBUG */
1092   case GL_DEBUG_OUTPUT:
1093   case GL_DEBUG_OUTPUT_SYNCHRONOUS:
1094   case GL_DEBUG_LOGGED_MESSAGES:
1095   case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
1096   case GL_DEBUG_GROUP_STACK_DEPTH:
1097      v->value_int = _mesa_get_debug_state_int(ctx, d->pname);
1098      break;
1099   /* GL_ARB_shader_atomic_counters */
1100   case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1101      if (ctx->AtomicBuffer) {
1102         v->value_int = ctx->AtomicBuffer->Name;
1103      } else {
1104         v->value_int = 0;
1105      }
1106      break;
1107   /* GL 4.3 */
1108   case GL_NUM_SHADING_LANGUAGE_VERSIONS:
1109      v->value_int = _mesa_get_shading_language_version(ctx, -1, NULL);
1110      break;
1111   /* GL_ARB_draw_indirect */
1112   case GL_DRAW_INDIRECT_BUFFER_BINDING:
1113      v->value_int = ctx->DrawIndirectBuffer->Name;
1114      break;
1115   /* GL_ARB_indirect_parameters */
1116   case GL_PARAMETER_BUFFER_BINDING_ARB:
1117      v->value_int = ctx->ParameterBuffer->Name;
1118      break;
1119   /* GL_ARB_separate_shader_objects */
1120   case GL_PROGRAM_PIPELINE_BINDING:
1121      if (ctx->Pipeline.Current) {
1122         v->value_int = ctx->Pipeline.Current->Name;
1123      } else {
1124         v->value_int = 0;
1125      }
1126      break;
1127   /* GL_ARB_compute_shader */
1128   case GL_DISPATCH_INDIRECT_BUFFER_BINDING:
1129      v->value_int = ctx->DispatchIndirectBuffer->Name;
1130      break;
1131   /* GL_ARB_multisample */
1132   case GL_SAMPLES:
1133      v->value_int = _mesa_geometric_samples(ctx->DrawBuffer);
1134      break;
1135   case GL_SAMPLE_BUFFERS:
1136      v->value_int = _mesa_geometric_samples(ctx->DrawBuffer) > 0;
1137      break;
1138   /* GL_EXT_textrue_integer */
1139   case GL_RGBA_INTEGER_MODE_EXT:
1140      v->value_int = (ctx->DrawBuffer->_IntegerBuffers != 0);
1141      break;
1142   /* GL_ATI_meminfo & GL_NVX_gpu_memory_info */
1143   case GL_VBO_FREE_MEMORY_ATI:
1144   case GL_TEXTURE_FREE_MEMORY_ATI:
1145   case GL_RENDERBUFFER_FREE_MEMORY_ATI:
1146   case GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX:
1147   case GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX:
1148   case GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX:
1149   case GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX:
1150   case GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX:
1151      {
1152         struct gl_memory_info info;
1153
1154         ctx->Driver.QueryMemoryInfo(ctx, &info);
1155
1156         if (d->pname == GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX)
1157            v->value_int = info.total_device_memory;
1158         else if (d->pname == GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX)
1159            v->value_int = info.total_device_memory +
1160                           info.total_staging_memory;
1161         else if (d->pname == GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX)
1162            v->value_int = info.avail_device_memory;
1163         else if (d->pname == GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX)
1164            v->value_int = info.nr_device_memory_evictions;
1165         else if (d->pname == GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX)
1166            v->value_int = info.device_memory_evicted;
1167         else {
1168            /* ATI free memory enums.
1169             *
1170             * Since the GPU memory is (usually) page-table based, every two
1171             * consecutive elements are equal. From the GL_ATI_meminfo
1172             * specification:
1173             *
1174             *    "param[0] - total memory free in the pool
1175             *     param[1] - largest available free block in the pool
1176             *     param[2] - total auxiliary memory free
1177             *     param[3] - largest auxiliary free block"
1178             *
1179             * All three (VBO, TEXTURE, RENDERBUFFER) queries return
1180             * the same numbers here.
1181             */
1182            v->value_int_4[0] = info.avail_device_memory;
1183            v->value_int_4[1] = info.avail_device_memory;
1184            v->value_int_4[2] = info.avail_staging_memory;
1185            v->value_int_4[3] = info.avail_staging_memory;
1186         }
1187      }
1188      break;
1189
1190   /* GL_ARB_get_program_binary */
1191   case GL_PROGRAM_BINARY_FORMATS:
1192      assert(ctx->Const.NumProgramBinaryFormats <= 1);
1193      v->value_int_n.n = MIN2(ctx->Const.NumProgramBinaryFormats, 1);
1194      if (ctx->Const.NumProgramBinaryFormats > 0) {
1195         v->value_int_n.ints[0] = GL_PROGRAM_BINARY_FORMAT_MESA;
1196      }
1197      break;
1198   /* GL_EXT_disjoint_timer_query */
1199   case GL_GPU_DISJOINT_EXT:
1200      {
1201         simple_mtx_lock(&ctx->Shared->Mutex);
1202         v->value_int = ctx->Shared->DisjointOperation;
1203         /* Reset state as expected by the spec. */
1204         ctx->Shared->DisjointOperation = false;
1205         simple_mtx_unlock(&ctx->Shared->Mutex);
1206      }
1207      break;
1208   /* GL_ARB_sample_locations */
1209   case GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB:
1210   case GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB:
1211   case GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB:
1212      {
1213         GLuint bits, width, height;
1214
1215         if (ctx->NewState & _NEW_BUFFERS)
1216            _mesa_update_state(ctx);
1217
1218         if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE) {
1219            v->value_uint = 0;
1220            break;
1221         }
1222
1223         ctx->Driver.GetProgrammableSampleCaps(ctx, ctx->DrawBuffer,
1224                                               &bits, &width, &height);
1225
1226         if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB)
1227            v->value_uint = width;
1228         else if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB)
1229            v->value_uint = height;
1230         else
1231            v->value_uint = bits;
1232      }
1233      break;
1234   case GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB:
1235      v->value_uint = MAX_SAMPLE_LOCATION_TABLE_SIZE;
1236      break;
1237
1238   /* GL_AMD_framebuffer_multisample_advanced */
1239   case GL_SUPPORTED_MULTISAMPLE_MODES_AMD:
1240      v->value_int_n.n = ctx->Const.NumSupportedMultisampleModes * 3;
1241      memcpy(v->value_int_n.ints, ctx->Const.SupportedMultisampleModes,
1242             v->value_int_n.n * sizeof(GLint));
1243      break;
1244   }
1245}
1246
1247/**
1248 * Check extra constraints on a struct value_desc descriptor
1249 *
1250 * If a struct value_desc has a non-NULL extra pointer, it means that
1251 * there are a number of extra constraints to check or actions to
1252 * perform.  The extras is just an integer array where each integer
1253 * encode different constraints or actions.
1254 *
1255 * \param ctx current context
1256 * \param func name of calling glGet*v() function for error reporting
1257 * \param d the struct value_desc that has the extra constraints
1258 *
1259 * \return GL_FALSE if all of the constraints were not satisfied,
1260 *     otherwise GL_TRUE.
1261 */
1262static GLboolean
1263check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)
1264{
1265   const GLuint version = ctx->Version;
1266   GLboolean api_check = GL_FALSE;
1267   GLboolean api_found = GL_FALSE;
1268   const int *e;
1269
1270   for (e = d->extra; *e != EXTRA_END; e++) {
1271      switch (*e) {
1272      case EXTRA_VERSION_30:
1273         api_check = GL_TRUE;
1274         if (version >= 30)
1275            api_found = GL_TRUE;
1276         break;
1277      case EXTRA_VERSION_31:
1278         api_check = GL_TRUE;
1279         if (version >= 31)
1280            api_found = GL_TRUE;
1281         break;
1282      case EXTRA_VERSION_32:
1283         api_check = GL_TRUE;
1284         if (version >= 32)
1285            api_found = GL_TRUE;
1286         break;
1287      case EXTRA_VERSION_40:
1288         api_check = GL_TRUE;
1289         if (version >= 40)
1290            api_found = GL_TRUE;
1291         break;
1292      case EXTRA_VERSION_43:
1293         api_check = TRUE;
1294         if (_mesa_is_desktop_gl(ctx) && version >= 43)
1295            api_found = GL_TRUE;
1296         break;
1297      case EXTRA_NEW_FRAG_CLAMP:
1298         if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
1299            _mesa_update_state(ctx);
1300         break;
1301      case EXTRA_API_ES2:
1302         api_check = GL_TRUE;
1303         if (ctx->API == API_OPENGLES2)
1304            api_found = GL_TRUE;
1305         break;
1306      case EXTRA_API_ES3:
1307         api_check = GL_TRUE;
1308         if (_mesa_is_gles3(ctx))
1309            api_found = GL_TRUE;
1310         break;
1311      case EXTRA_API_ES31:
1312         api_check = GL_TRUE;
1313         if (_mesa_is_gles31(ctx))
1314            api_found = GL_TRUE;
1315         break;
1316      case EXTRA_API_ES32:
1317         api_check = GL_TRUE;
1318         if (_mesa_is_gles32(ctx))
1319            api_found = GL_TRUE;
1320         break;
1321      case EXTRA_API_GL:
1322         api_check = GL_TRUE;
1323         if (_mesa_is_desktop_gl(ctx))
1324            api_found = GL_TRUE;
1325         break;
1326      case EXTRA_API_GL_CORE:
1327         api_check = GL_TRUE;
1328         if (ctx->API == API_OPENGL_CORE)
1329            api_found = GL_TRUE;
1330         break;
1331      case EXTRA_NEW_BUFFERS:
1332         if (ctx->NewState & _NEW_BUFFERS)
1333            _mesa_update_state(ctx);
1334         break;
1335      case EXTRA_FLUSH_CURRENT:
1336         FLUSH_CURRENT(ctx, 0);
1337         break;
1338      case EXTRA_VALID_DRAW_BUFFER:
1339         if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
1340            _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
1341                        func, d->pname - GL_DRAW_BUFFER0_ARB);
1342            return GL_FALSE;
1343         }
1344         break;
1345      case EXTRA_VALID_TEXTURE_UNIT:
1346         if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
1347            _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
1348                        func, ctx->Texture.CurrentUnit);
1349            return GL_FALSE;
1350         }
1351         break;
1352      case EXTRA_VALID_CLIP_DISTANCE:
1353         if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) {
1354            _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)",
1355                        func, d->pname - GL_CLIP_DISTANCE0);
1356            return GL_FALSE;
1357         }
1358         break;
1359      case EXTRA_GLSL_130:
1360         api_check = GL_TRUE;
1361         if (ctx->Const.GLSLVersion >= 130)
1362            api_found = GL_TRUE;
1363         break;
1364      case EXTRA_EXT_UBO_GS:
1365         api_check = GL_TRUE;
1366         if (ctx->Extensions.ARB_uniform_buffer_object &&
1367            _mesa_has_geometry_shaders(ctx))
1368            api_found = GL_TRUE;
1369         break;
1370      case EXTRA_EXT_ATOMICS_GS:
1371         api_check = GL_TRUE;
1372         if (ctx->Extensions.ARB_shader_atomic_counters &&
1373            _mesa_has_geometry_shaders(ctx))
1374            api_found = GL_TRUE;
1375         break;
1376      case EXTRA_EXT_SHADER_IMAGE_GS:
1377         api_check = GL_TRUE;
1378         if (ctx->Extensions.ARB_shader_image_load_store &&
1379            _mesa_has_geometry_shaders(ctx))
1380            api_found = GL_TRUE;
1381         break;
1382      case EXTRA_EXT_ATOMICS_TESS:
1383         api_check = GL_TRUE;
1384         api_found = ctx->Extensions.ARB_shader_atomic_counters &&
1385                     _mesa_has_tessellation(ctx);
1386         break;
1387      case EXTRA_EXT_SHADER_IMAGE_TESS:
1388         api_check = GL_TRUE;
1389         api_found = ctx->Extensions.ARB_shader_image_load_store &&
1390                     _mesa_has_tessellation(ctx);
1391         break;
1392      case EXTRA_EXT_SSBO_GS:
1393         api_check = GL_TRUE;
1394         if (ctx->Extensions.ARB_shader_storage_buffer_object &&
1395            _mesa_has_geometry_shaders(ctx))
1396            api_found = GL_TRUE;
1397         break;
1398      case EXTRA_EXT_FB_NO_ATTACH_GS:
1399         api_check = GL_TRUE;
1400         if (ctx->Extensions.ARB_framebuffer_no_attachments &&
1401            (_mesa_is_desktop_gl(ctx) ||
1402            _mesa_has_OES_geometry_shader(ctx)))
1403            api_found = GL_TRUE;
1404         break;
1405      case EXTRA_EXT_ES_GS:
1406         api_check = GL_TRUE;
1407         if (_mesa_has_OES_geometry_shader(ctx))
1408            api_found = GL_TRUE;
1409         break;
1410      case EXTRA_EXT_PROVOKING_VERTEX_32:
1411         api_check = TRUE;
1412         if (ctx->API == API_OPENGL_COMPAT || version == 32)
1413            api_found = ctx->Extensions.EXT_provoking_vertex;
1414         break;
1415      case EXTRA_END:
1416         break;
1417      default: /* *e is a offset into the extension struct */
1418         api_check = GL_TRUE;
1419         if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
1420            api_found = GL_TRUE;
1421         break;
1422      }
1423   }
1424
1425   if (api_check && !api_found) {
1426      _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1427                  _mesa_enum_to_string(d->pname));
1428      return GL_FALSE;
1429   }
1430
1431   return GL_TRUE;
1432}
1433
1434static const struct value_desc error_value =
1435   { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
1436
1437/**
1438 * Find the struct value_desc corresponding to the enum 'pname'.
1439 *
1440 * We hash the enum value to get an index into the 'table' array,
1441 * which holds the index in the 'values' array of struct value_desc.
1442 * Once we've found the entry, we do the extra checks, if any, then
1443 * look up the value and return a pointer to it.
1444 *
1445 * If the value has to be computed (for example, it's the result of a
1446 * function call or we need to add 1 to it), we use the tmp 'v' to
1447 * store the result.
1448 *
1449 * \param func name of glGet*v() func for error reporting
1450 * \param pname the enum value we're looking up
1451 * \param p is were we return the pointer to the value
1452 * \param v a tmp union value variable in the calling glGet*v() function
1453 *
1454 * \return the struct value_desc corresponding to the enum or a struct
1455 *     value_desc of TYPE_INVALID if not found.  This lets the calling
1456 *     glGet*v() function jump right into a switch statement and
1457 *     handle errors there instead of having to check for NULL.
1458 */
1459static const struct value_desc *
1460find_value(const char *func, GLenum pname, void **p, union value *v)
1461{
1462   GET_CURRENT_CONTEXT(ctx);
1463   int mask, hash;
1464   const struct value_desc *d;
1465   int api;
1466
1467   api = ctx->API;
1468   /* We index into the table_set[] list of per-API hash tables using the API's
1469    * value in the gl_api enum. Since GLES 3 doesn't have an API_OPENGL* enum
1470    * value since it's compatible with GLES2 its entry in table_set[] is at the
1471    * end.
1472    */
1473   STATIC_ASSERT(ARRAY_SIZE(table_set) == API_OPENGL_LAST + 4);
1474   if (ctx->API == API_OPENGLES2) {
1475      if (ctx->Version >= 32)
1476         api = API_OPENGL_LAST + 3;
1477      else if (ctx->Version >= 31)
1478         api = API_OPENGL_LAST + 2;
1479      else if (ctx->Version >= 30)
1480         api = API_OPENGL_LAST + 1;
1481   }
1482   mask = ARRAY_SIZE(table(api)) - 1;
1483   hash = (pname * prime_factor);
1484   while (1) {
1485      int idx = table(api)[hash & mask];
1486
1487      /* If the enum isn't valid, the hash walk ends with index 0,
1488       * pointing to the first entry of values[] which doesn't hold
1489       * any valid enum. */
1490      if (unlikely(idx == 0)) {
1491         _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1492               _mesa_enum_to_string(pname));
1493         return &error_value;
1494      }
1495
1496      d = &values[idx];
1497      if (likely(d->pname == pname))
1498         break;
1499
1500      hash += prime_step;
1501   }
1502
1503   if (unlikely(d->extra && !check_extra(ctx, func, d)))
1504      return &error_value;
1505
1506   switch (d->location) {
1507   case LOC_BUFFER:
1508      *p = ((char *) ctx->DrawBuffer + d->offset);
1509      return d;
1510   case LOC_CONTEXT:
1511      *p = ((char *) ctx + d->offset);
1512      return d;
1513   case LOC_ARRAY:
1514      *p = ((char *) ctx->Array.VAO + d->offset);
1515      return d;
1516   case LOC_TEXUNIT:
1517      if (ctx->Texture.CurrentUnit < ARRAY_SIZE(ctx->Texture.FixedFuncUnit)) {
1518         unsigned index = ctx->Texture.CurrentUnit;
1519         *p = ((char *)&ctx->Texture.FixedFuncUnit[index] + d->offset);
1520      }
1521      return d;
1522   case LOC_CUSTOM:
1523      find_custom_value(ctx, d, v);
1524      *p = v;
1525      return d;
1526   default:
1527      assert(0);
1528      break;
1529   }
1530
1531   /* silence warning */
1532   return &error_value;
1533}
1534
1535static const int transpose[] = {
1536   0, 4,  8, 12,
1537   1, 5,  9, 13,
1538   2, 6, 10, 14,
1539   3, 7, 11, 15
1540};
1541
1542static GLsizei
1543get_value_size(enum value_type type, const union value *v)
1544{
1545   switch (type) {
1546   case TYPE_INVALID:
1547      return 0;
1548   case TYPE_CONST:
1549   case TYPE_UINT:
1550   case TYPE_INT:
1551      return sizeof(GLint);
1552   case TYPE_INT_2:
1553   case TYPE_UINT_2:
1554      return sizeof(GLint) * 2;
1555   case TYPE_INT_3:
1556   case TYPE_UINT_3:
1557      return sizeof(GLint) * 3;
1558   case TYPE_INT_4:
1559   case TYPE_UINT_4:
1560      return sizeof(GLint) * 4;
1561   case TYPE_INT_N:
1562      return sizeof(GLint) * v->value_int_n.n;
1563   case TYPE_INT64:
1564      return sizeof(GLint64);
1565      break;
1566   case TYPE_ENUM16:
1567      return sizeof(GLenum16);
1568   case TYPE_ENUM:
1569      return sizeof(GLenum);
1570   case TYPE_ENUM_2:
1571      return sizeof(GLenum) * 2;
1572   case TYPE_BOOLEAN:
1573      return sizeof(GLboolean);
1574   case TYPE_UBYTE:
1575      return sizeof(GLubyte);
1576   case TYPE_SHORT:
1577      return sizeof(GLshort);
1578   case TYPE_BIT_0:
1579   case TYPE_BIT_1:
1580   case TYPE_BIT_2:
1581   case TYPE_BIT_3:
1582   case TYPE_BIT_4:
1583   case TYPE_BIT_5:
1584   case TYPE_BIT_6:
1585   case TYPE_BIT_7:
1586      return 1;
1587   case TYPE_FLOAT:
1588   case TYPE_FLOATN:
1589      return sizeof(GLfloat);
1590   case TYPE_FLOAT_2:
1591   case TYPE_FLOATN_2:
1592      return sizeof(GLfloat) * 2;
1593   case TYPE_FLOAT_3:
1594   case TYPE_FLOATN_3:
1595      return sizeof(GLfloat) * 3;
1596   case TYPE_FLOAT_4:
1597   case TYPE_FLOATN_4:
1598      return sizeof(GLfloat) * 4;
1599   case TYPE_FLOAT_8:
1600      return sizeof(GLfloat) * 8;
1601   case TYPE_DOUBLEN:
1602      return sizeof(GLdouble);
1603   case TYPE_DOUBLEN_2:
1604      return sizeof(GLdouble) * 2;
1605   case TYPE_MATRIX:
1606      return sizeof (GLfloat) * 16;
1607   case TYPE_MATRIX_T:
1608      return sizeof (GLfloat) * 16;
1609   default:
1610      return -1;
1611   }
1612}
1613
1614void GLAPIENTRY
1615_mesa_GetBooleanv(GLenum pname, GLboolean *params)
1616{
1617   const struct value_desc *d;
1618   union value v;
1619   GLmatrix *m;
1620   int shift, i;
1621   void *p;
1622
1623   d = find_value("glGetBooleanv", pname, &p, &v);
1624   switch (d->type) {
1625   case TYPE_INVALID:
1626      break;
1627   case TYPE_CONST:
1628      params[0] = INT_TO_BOOLEAN(d->offset);
1629      break;
1630
1631   case TYPE_FLOAT_8:
1632      params[7] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[7]);
1633      params[6] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[6]);
1634      params[5] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[5]);
1635      params[4] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[4]);
1636   case TYPE_FLOAT_4:
1637   case TYPE_FLOATN_4:
1638      params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
1639   case TYPE_FLOAT_3:
1640   case TYPE_FLOATN_3:
1641      params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
1642   case TYPE_FLOAT_2:
1643   case TYPE_FLOATN_2:
1644      params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
1645   case TYPE_FLOAT:
1646   case TYPE_FLOATN:
1647      params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
1648      break;
1649
1650   case TYPE_DOUBLEN_2:
1651      params[1] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[1]);
1652   case TYPE_DOUBLEN:
1653      params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
1654      break;
1655
1656   case TYPE_INT_4:
1657   case TYPE_UINT_4:
1658      params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
1659   case TYPE_INT_3:
1660   case TYPE_UINT_3:
1661      params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
1662   case TYPE_INT_2:
1663   case TYPE_UINT_2:
1664   case TYPE_ENUM_2:
1665      params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
1666   case TYPE_INT:
1667   case TYPE_UINT:
1668   case TYPE_ENUM:
1669      params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
1670      break;
1671
1672   case TYPE_ENUM16:
1673      params[0] = INT_TO_BOOLEAN(((GLenum16 *) p)[0]);
1674      break;
1675
1676   case TYPE_INT_N:
1677      for (i = 0; i < v.value_int_n.n; i++)
1678         params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
1679      break;
1680
1681   case TYPE_INT64:
1682      params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
1683      break;
1684
1685   case TYPE_BOOLEAN:
1686      params[0] = ((GLboolean*) p)[0];
1687      break;
1688
1689   case TYPE_UBYTE:
1690      params[0] = INT_TO_BOOLEAN(((GLubyte *) p)[0]);
1691      break;
1692
1693   case TYPE_SHORT:
1694      params[0] = INT_TO_BOOLEAN(((GLshort *) p)[0]);
1695      break;
1696
1697   case TYPE_MATRIX:
1698      m = *(GLmatrix **) p;
1699      for (i = 0; i < 16; i++)
1700         params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
1701      break;
1702
1703   case TYPE_MATRIX_T:
1704      m = *(GLmatrix **) p;
1705      for (i = 0; i < 16; i++)
1706         params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
1707      break;
1708
1709   case TYPE_BIT_0:
1710   case TYPE_BIT_1:
1711   case TYPE_BIT_2:
1712   case TYPE_BIT_3:
1713   case TYPE_BIT_4:
1714   case TYPE_BIT_5:
1715   case TYPE_BIT_6:
1716   case TYPE_BIT_7:
1717      shift = d->type - TYPE_BIT_0;
1718      params[0] = (*(GLbitfield *) p >> shift) & 1;
1719      break;
1720   }
1721}
1722
1723void GLAPIENTRY
1724_mesa_GetFloatv(GLenum pname, GLfloat *params)
1725{
1726   const struct value_desc *d;
1727   union value v;
1728   GLmatrix *m;
1729   int shift, i;
1730   void *p;
1731
1732   d = find_value("glGetFloatv", pname, &p, &v);
1733   switch (d->type) {
1734   case TYPE_INVALID:
1735      break;
1736   case TYPE_CONST:
1737      params[0] = (GLfloat) d->offset;
1738      break;
1739
1740   case TYPE_FLOAT_8:
1741      params[7] = ((GLfloat *) p)[7];
1742      params[6] = ((GLfloat *) p)[6];
1743      params[5] = ((GLfloat *) p)[5];
1744      params[4] = ((GLfloat *) p)[4];
1745   case TYPE_FLOAT_4:
1746   case TYPE_FLOATN_4:
1747      params[3] = ((GLfloat *) p)[3];
1748   case TYPE_FLOAT_3:
1749   case TYPE_FLOATN_3:
1750      params[2] = ((GLfloat *) p)[2];
1751   case TYPE_FLOAT_2:
1752   case TYPE_FLOATN_2:
1753      params[1] = ((GLfloat *) p)[1];
1754   case TYPE_FLOAT:
1755   case TYPE_FLOATN:
1756      params[0] = ((GLfloat *) p)[0];
1757      break;
1758
1759   case TYPE_DOUBLEN_2:
1760      params[1] = (GLfloat) (((GLdouble *) p)[1]);
1761   case TYPE_DOUBLEN:
1762      params[0] = (GLfloat) (((GLdouble *) p)[0]);
1763      break;
1764
1765   case TYPE_INT_4:
1766      params[3] = (GLfloat) (((GLint *) p)[3]);
1767   case TYPE_INT_3:
1768      params[2] = (GLfloat) (((GLint *) p)[2]);
1769   case TYPE_INT_2:
1770   case TYPE_ENUM_2:
1771      params[1] = (GLfloat) (((GLint *) p)[1]);
1772   case TYPE_INT:
1773   case TYPE_ENUM:
1774      params[0] = (GLfloat) (((GLint *) p)[0]);
1775      break;
1776
1777   case TYPE_ENUM16:
1778      params[0] = (GLfloat) (((GLenum16 *) p)[0]);
1779      break;
1780
1781   case TYPE_INT_N:
1782      for (i = 0; i < v.value_int_n.n; i++)
1783         params[i] = (GLfloat) v.value_int_n.ints[i];
1784      break;
1785
1786   case TYPE_UINT_4:
1787      params[3] = (GLfloat) (((GLuint *) p)[3]);
1788   case TYPE_UINT_3:
1789      params[2] = (GLfloat) (((GLuint *) p)[2]);
1790   case TYPE_UINT_2:
1791      params[1] = (GLfloat) (((GLuint *) p)[1]);
1792   case TYPE_UINT:
1793      params[0] = (GLfloat) (((GLuint *) p)[0]);
1794      break;
1795
1796   case TYPE_INT64:
1797      params[0] = (GLfloat) (((GLint64 *) p)[0]);
1798      break;
1799
1800   case TYPE_BOOLEAN:
1801      params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
1802      break;
1803
1804   case TYPE_UBYTE:
1805      params[0] = (GLfloat) ((GLubyte *) p)[0];
1806      break;
1807
1808   case TYPE_SHORT:
1809      params[0] = (GLfloat) ((GLshort *) p)[0];
1810      break;
1811
1812   case TYPE_MATRIX:
1813      m = *(GLmatrix **) p;
1814      for (i = 0; i < 16; i++)
1815         params[i] = m->m[i];
1816      break;
1817
1818   case TYPE_MATRIX_T:
1819      m = *(GLmatrix **) p;
1820      for (i = 0; i < 16; i++)
1821         params[i] = m->m[transpose[i]];
1822      break;
1823
1824   case TYPE_BIT_0:
1825   case TYPE_BIT_1:
1826   case TYPE_BIT_2:
1827   case TYPE_BIT_3:
1828   case TYPE_BIT_4:
1829   case TYPE_BIT_5:
1830   case TYPE_BIT_6:
1831   case TYPE_BIT_7:
1832      shift = d->type - TYPE_BIT_0;
1833      params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);
1834      break;
1835   }
1836}
1837
1838void GLAPIENTRY
1839_mesa_GetIntegerv(GLenum pname, GLint *params)
1840{
1841   const struct value_desc *d;
1842   union value v;
1843   GLmatrix *m;
1844   int shift, i;
1845   void *p;
1846
1847   d = find_value("glGetIntegerv", pname, &p, &v);
1848   switch (d->type) {
1849   case TYPE_INVALID:
1850      break;
1851   case TYPE_CONST:
1852      params[0] = d->offset;
1853      break;
1854
1855   case TYPE_FLOAT_8:
1856      params[7] = IROUND(((GLfloat *) p)[7]);
1857      params[6] = IROUND(((GLfloat *) p)[6]);
1858      params[5] = IROUND(((GLfloat *) p)[5]);
1859      params[4] = IROUND(((GLfloat *) p)[4]);
1860   case TYPE_FLOAT_4:
1861      params[3] = IROUND(((GLfloat *) p)[3]);
1862   case TYPE_FLOAT_3:
1863      params[2] = IROUND(((GLfloat *) p)[2]);
1864   case TYPE_FLOAT_2:
1865      params[1] = IROUND(((GLfloat *) p)[1]);
1866   case TYPE_FLOAT:
1867      params[0] = IROUND(((GLfloat *) p)[0]);
1868      break;
1869
1870   case TYPE_FLOATN_4:
1871      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
1872   case TYPE_FLOATN_3:
1873      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
1874   case TYPE_FLOATN_2:
1875      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
1876   case TYPE_FLOATN:
1877      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
1878      break;
1879
1880   case TYPE_DOUBLEN_2:
1881      params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]);
1882   case TYPE_DOUBLEN:
1883      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
1884      break;
1885
1886   case TYPE_INT_4:
1887   case TYPE_UINT_4:
1888      params[3] = ((GLint *) p)[3];
1889   case TYPE_INT_3:
1890   case TYPE_UINT_3:
1891      params[2] = ((GLint *) p)[2];
1892   case TYPE_INT_2:
1893   case TYPE_UINT_2:
1894   case TYPE_ENUM_2:
1895      params[1] = ((GLint *) p)[1];
1896   case TYPE_INT:
1897   case TYPE_UINT:
1898   case TYPE_ENUM:
1899      params[0] = ((GLint *) p)[0];
1900      break;
1901
1902   case TYPE_ENUM16:
1903      params[0] = ((GLenum16 *) p)[0];
1904      break;
1905
1906   case TYPE_INT_N:
1907      for (i = 0; i < v.value_int_n.n; i++)
1908         params[i] = v.value_int_n.ints[i];
1909      break;
1910
1911   case TYPE_INT64:
1912      params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
1913      break;
1914
1915   case TYPE_BOOLEAN:
1916      params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
1917      break;
1918
1919   case TYPE_UBYTE:
1920      params[0] = ((GLubyte *) p)[0];
1921      break;
1922
1923   case TYPE_SHORT:
1924      params[0] = ((GLshort *) p)[0];
1925      break;
1926
1927   case TYPE_MATRIX:
1928      m = *(GLmatrix **) p;
1929      for (i = 0; i < 16; i++)
1930         params[i] = FLOAT_TO_INT(m->m[i]);
1931      break;
1932
1933   case TYPE_MATRIX_T:
1934      m = *(GLmatrix **) p;
1935      for (i = 0; i < 16; i++)
1936         params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
1937      break;
1938
1939   case TYPE_BIT_0:
1940   case TYPE_BIT_1:
1941   case TYPE_BIT_2:
1942   case TYPE_BIT_3:
1943   case TYPE_BIT_4:
1944   case TYPE_BIT_5:
1945   case TYPE_BIT_6:
1946   case TYPE_BIT_7:
1947      shift = d->type - TYPE_BIT_0;
1948      params[0] = (*(GLbitfield *) p >> shift) & 1;
1949      break;
1950   }
1951}
1952
1953void GLAPIENTRY
1954_mesa_GetInteger64v(GLenum pname, GLint64 *params)
1955{
1956   const struct value_desc *d;
1957   union value v;
1958   GLmatrix *m;
1959   int shift, i;
1960   void *p;
1961
1962   d = find_value("glGetInteger64v", pname, &p, &v);
1963   switch (d->type) {
1964   case TYPE_INVALID:
1965      break;
1966   case TYPE_CONST:
1967      params[0] = d->offset;
1968      break;
1969
1970   case TYPE_FLOAT_8:
1971      params[7] = IROUND64(((GLfloat *) p)[7]);
1972      params[6] = IROUND64(((GLfloat *) p)[6]);
1973      params[5] = IROUND64(((GLfloat *) p)[5]);
1974      params[4] = IROUND64(((GLfloat *) p)[4]);
1975   case TYPE_FLOAT_4:
1976      params[3] = IROUND64(((GLfloat *) p)[3]);
1977   case TYPE_FLOAT_3:
1978      params[2] = IROUND64(((GLfloat *) p)[2]);
1979   case TYPE_FLOAT_2:
1980      params[1] = IROUND64(((GLfloat *) p)[1]);
1981   case TYPE_FLOAT:
1982      params[0] = IROUND64(((GLfloat *) p)[0]);
1983      break;
1984
1985   case TYPE_FLOATN_4:
1986      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
1987   case TYPE_FLOATN_3:
1988      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
1989   case TYPE_FLOATN_2:
1990      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
1991   case TYPE_FLOATN:
1992      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
1993      break;
1994
1995   case TYPE_DOUBLEN_2:
1996      params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]);
1997   case TYPE_DOUBLEN:
1998      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
1999      break;
2000
2001   case TYPE_INT_4:
2002      params[3] = ((GLint *) p)[3];
2003   case TYPE_INT_3:
2004      params[2] = ((GLint *) p)[2];
2005   case TYPE_INT_2:
2006   case TYPE_ENUM_2:
2007      params[1] = ((GLint *) p)[1];
2008   case TYPE_INT:
2009   case TYPE_ENUM:
2010      params[0] = ((GLint *) p)[0];
2011      break;
2012
2013   case TYPE_ENUM16:
2014      params[0] = ((GLenum16 *) p)[0];
2015      break;
2016
2017   case TYPE_INT_N:
2018      for (i = 0; i < v.value_int_n.n; i++)
2019         params[i] = v.value_int_n.ints[i];
2020      break;
2021
2022   case TYPE_UINT_4:
2023      params[3] = ((GLuint *) p)[3];
2024   case TYPE_UINT_3:
2025      params[2] = ((GLuint *) p)[2];
2026   case TYPE_UINT_2:
2027      params[1] = ((GLuint *) p)[1];
2028   case TYPE_UINT:
2029      params[0] = ((GLuint *) p)[0];
2030      break;
2031
2032   case TYPE_INT64:
2033      params[0] = ((GLint64 *) p)[0];
2034      break;
2035
2036   case TYPE_BOOLEAN:
2037      params[0] = ((GLboolean*) p)[0];
2038      break;
2039
2040   case TYPE_MATRIX:
2041      m = *(GLmatrix **) p;
2042      for (i = 0; i < 16; i++)
2043         params[i] = FLOAT_TO_INT64(m->m[i]);
2044      break;
2045
2046   case TYPE_MATRIX_T:
2047      m = *(GLmatrix **) p;
2048      for (i = 0; i < 16; i++)
2049         params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
2050      break;
2051
2052   case TYPE_BIT_0:
2053   case TYPE_BIT_1:
2054   case TYPE_BIT_2:
2055   case TYPE_BIT_3:
2056   case TYPE_BIT_4:
2057   case TYPE_BIT_5:
2058   case TYPE_BIT_6:
2059   case TYPE_BIT_7:
2060      shift = d->type - TYPE_BIT_0;
2061      params[0] = (*(GLbitfield *) p >> shift) & 1;
2062      break;
2063   }
2064}
2065
2066void GLAPIENTRY
2067_mesa_GetDoublev(GLenum pname, GLdouble *params)
2068{
2069   const struct value_desc *d;
2070   union value v;
2071   GLmatrix *m;
2072   int shift, i;
2073   void *p;
2074
2075   d = find_value("glGetDoublev", pname, &p, &v);
2076   switch (d->type) {
2077   case TYPE_INVALID:
2078      break;
2079   case TYPE_CONST:
2080      params[0] = d->offset;
2081      break;
2082
2083   case TYPE_FLOAT_8:
2084      params[7] = ((GLfloat *) p)[7];
2085      params[6] = ((GLfloat *) p)[6];
2086      params[5] = ((GLfloat *) p)[5];
2087      params[4] = ((GLfloat *) p)[4];
2088   case TYPE_FLOAT_4:
2089   case TYPE_FLOATN_4:
2090      params[3] = ((GLfloat *) p)[3];
2091   case TYPE_FLOAT_3:
2092   case TYPE_FLOATN_3:
2093      params[2] = ((GLfloat *) p)[2];
2094   case TYPE_FLOAT_2:
2095   case TYPE_FLOATN_2:
2096      params[1] = ((GLfloat *) p)[1];
2097   case TYPE_FLOAT:
2098   case TYPE_FLOATN:
2099      params[0] = ((GLfloat *) p)[0];
2100      break;
2101
2102   case TYPE_DOUBLEN_2:
2103      params[1] = ((GLdouble *) p)[1];
2104   case TYPE_DOUBLEN:
2105      params[0] = ((GLdouble *) p)[0];
2106      break;
2107
2108   case TYPE_INT_4:
2109      params[3] = ((GLint *) p)[3];
2110   case TYPE_INT_3:
2111      params[2] = ((GLint *) p)[2];
2112   case TYPE_INT_2:
2113   case TYPE_ENUM_2:
2114      params[1] = ((GLint *) p)[1];
2115   case TYPE_INT:
2116   case TYPE_ENUM:
2117      params[0] = ((GLint *) p)[0];
2118      break;
2119
2120   case TYPE_ENUM16:
2121      params[0] = ((GLenum16 *) p)[0];
2122      break;
2123
2124   case TYPE_INT_N:
2125      for (i = 0; i < v.value_int_n.n; i++)
2126         params[i] = v.value_int_n.ints[i];
2127      break;
2128
2129   case TYPE_UINT_4:
2130      params[3] = ((GLuint *) p)[3];
2131   case TYPE_UINT_3:
2132      params[2] = ((GLuint *) p)[2];
2133   case TYPE_UINT_2:
2134      params[1] = ((GLuint *) p)[1];
2135   case TYPE_UINT:
2136      params[0] = ((GLuint *) p)[0];
2137      break;
2138
2139   case TYPE_INT64:
2140      params[0] = (GLdouble) (((GLint64 *) p)[0]);
2141      break;
2142
2143   case TYPE_BOOLEAN:
2144      params[0] = *(GLboolean*) p;
2145      break;
2146
2147   case TYPE_UBYTE:
2148      params[0] = ((GLubyte *) p)[0];
2149      break;
2150
2151   case TYPE_SHORT:
2152      params[0] = ((GLshort *) p)[0];
2153      break;
2154
2155   case TYPE_MATRIX:
2156      m = *(GLmatrix **) p;
2157      for (i = 0; i < 16; i++)
2158         params[i] = m->m[i];
2159      break;
2160
2161   case TYPE_MATRIX_T:
2162      m = *(GLmatrix **) p;
2163      for (i = 0; i < 16; i++)
2164         params[i] = m->m[transpose[i]];
2165      break;
2166
2167   case TYPE_BIT_0:
2168   case TYPE_BIT_1:
2169   case TYPE_BIT_2:
2170   case TYPE_BIT_3:
2171   case TYPE_BIT_4:
2172   case TYPE_BIT_5:
2173   case TYPE_BIT_6:
2174   case TYPE_BIT_7:
2175      shift = d->type - TYPE_BIT_0;
2176      params[0] = (*(GLbitfield *) p >> shift) & 1;
2177      break;
2178   }
2179}
2180
2181void GLAPIENTRY
2182_mesa_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
2183{
2184   const struct value_desc *d;
2185   union value v;
2186   int shift;
2187   void *p = NULL;
2188   GLsizei size;
2189   const char *func = "glGetUnsignedBytevEXT";
2190
2191   GET_CURRENT_CONTEXT(ctx);
2192
2193   if (!ctx->Extensions.EXT_memory_object) {
2194      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
2195      return;
2196   }
2197
2198   d = find_value(func, pname, &p, &v);
2199   size = get_value_size(d->type, &v);
2200   if (size <= 0) {
2201      _mesa_problem(ctx, "invalid value type in GetUnsignedBytevEXT()");
2202   }
2203
2204   switch (d->type) {
2205   case TYPE_BIT_0:
2206   case TYPE_BIT_1:
2207   case TYPE_BIT_2:
2208   case TYPE_BIT_3:
2209   case TYPE_BIT_4:
2210   case TYPE_BIT_5:
2211   case TYPE_BIT_6:
2212   case TYPE_BIT_7:
2213      shift = d->type - TYPE_BIT_0;
2214      data[0] = (*(GLbitfield *) p >> shift) & 1;
2215      break;
2216   case TYPE_CONST:
2217      memcpy(data, &d->offset, size);
2218      break;
2219   case TYPE_INT_N:
2220      memcpy(data, &v.value_int_n.ints, size);
2221      break;
2222   case TYPE_UINT:
2223   case TYPE_INT:
2224   case TYPE_INT_2:
2225   case TYPE_UINT_2:
2226   case TYPE_INT_3:
2227   case TYPE_UINT_3:
2228   case TYPE_INT_4:
2229   case TYPE_UINT_4:
2230   case TYPE_INT64:
2231   case TYPE_ENUM:
2232   case TYPE_ENUM_2:
2233   case TYPE_BOOLEAN:
2234   case TYPE_UBYTE:
2235   case TYPE_SHORT:
2236   case TYPE_FLOAT:
2237   case TYPE_FLOATN:
2238   case TYPE_FLOAT_2:
2239   case TYPE_FLOATN_2:
2240   case TYPE_FLOAT_3:
2241   case TYPE_FLOATN_3:
2242   case TYPE_FLOAT_4:
2243   case TYPE_FLOATN_4:
2244   case TYPE_FLOAT_8:
2245   case TYPE_DOUBLEN:
2246   case TYPE_DOUBLEN_2:
2247   case TYPE_MATRIX:
2248   case TYPE_MATRIX_T:
2249      memcpy(data, p, size);
2250      break;
2251   case TYPE_ENUM16: {
2252      GLenum e = *(GLenum16 *)p;
2253      memcpy(data, &e, sizeof(e));
2254      break;
2255   }
2256   default:
2257      break; /* nothing - GL error was recorded */
2258   }
2259}
2260
2261/**
2262 * Convert a GL texture binding enum such as GL_TEXTURE_BINDING_2D
2263 * into the corresponding Mesa texture target index.
2264 * \return TEXTURE_x_INDEX or -1 if binding is invalid
2265 */
2266static int
2267tex_binding_to_index(const struct gl_context *ctx, GLenum binding)
2268{
2269   switch (binding) {
2270   case GL_TEXTURE_BINDING_1D:
2271      return _mesa_is_desktop_gl(ctx) ? TEXTURE_1D_INDEX : -1;
2272   case GL_TEXTURE_BINDING_2D:
2273      return TEXTURE_2D_INDEX;
2274   case GL_TEXTURE_BINDING_3D:
2275      return ctx->API != API_OPENGLES ? TEXTURE_3D_INDEX : -1;
2276   case GL_TEXTURE_BINDING_CUBE_MAP:
2277      return ctx->Extensions.ARB_texture_cube_map
2278         ? TEXTURE_CUBE_INDEX : -1;
2279   case GL_TEXTURE_BINDING_RECTANGLE:
2280      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.NV_texture_rectangle
2281         ? TEXTURE_RECT_INDEX : -1;
2282   case GL_TEXTURE_BINDING_1D_ARRAY:
2283      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_array
2284         ? TEXTURE_1D_ARRAY_INDEX : -1;
2285   case GL_TEXTURE_BINDING_2D_ARRAY:
2286      return (_mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_array)
2287         || _mesa_is_gles3(ctx)
2288         ? TEXTURE_2D_ARRAY_INDEX : -1;
2289   case GL_TEXTURE_BINDING_BUFFER:
2290      return (_mesa_has_ARB_texture_buffer_object(ctx) ||
2291              _mesa_has_OES_texture_buffer(ctx)) ?
2292             TEXTURE_BUFFER_INDEX : -1;
2293   case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2294      return _mesa_has_texture_cube_map_array(ctx)
2295         ? TEXTURE_CUBE_ARRAY_INDEX : -1;
2296   case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2297      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_multisample
2298         ? TEXTURE_2D_MULTISAMPLE_INDEX : -1;
2299   case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2300      return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_multisample
2301         ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : -1;
2302   default:
2303      return -1;
2304   }
2305}
2306
2307static enum value_type
2308find_value_indexed(const char *func, GLenum pname, GLuint index, union value *v)
2309{
2310   GET_CURRENT_CONTEXT(ctx);
2311
2312   switch (pname) {
2313
2314   case GL_BLEND:
2315      if (index >= ctx->Const.MaxDrawBuffers)
2316         goto invalid_value;
2317      if (!ctx->Extensions.EXT_draw_buffers2)
2318         goto invalid_enum;
2319      v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
2320      return TYPE_INT;
2321
2322   case GL_BLEND_SRC:
2323      /* fall-through */
2324   case GL_BLEND_SRC_RGB:
2325      if (index >= ctx->Const.MaxDrawBuffers)
2326         goto invalid_value;
2327      if (!ctx->Extensions.ARB_draw_buffers_blend)
2328         goto invalid_enum;
2329      v->value_int = ctx->Color.Blend[index].SrcRGB;
2330      return TYPE_INT;
2331   case GL_BLEND_SRC_ALPHA:
2332      if (index >= ctx->Const.MaxDrawBuffers)
2333         goto invalid_value;
2334      if (!ctx->Extensions.ARB_draw_buffers_blend)
2335         goto invalid_enum;
2336      v->value_int = ctx->Color.Blend[index].SrcA;
2337      return TYPE_INT;
2338   case GL_BLEND_DST:
2339      /* fall-through */
2340   case GL_BLEND_DST_RGB:
2341      if (index >= ctx->Const.MaxDrawBuffers)
2342         goto invalid_value;
2343      if (!ctx->Extensions.ARB_draw_buffers_blend)
2344         goto invalid_enum;
2345      v->value_int = ctx->Color.Blend[index].DstRGB;
2346      return TYPE_INT;
2347   case GL_BLEND_DST_ALPHA:
2348      if (index >= ctx->Const.MaxDrawBuffers)
2349         goto invalid_value;
2350      if (!ctx->Extensions.ARB_draw_buffers_blend)
2351         goto invalid_enum;
2352      v->value_int = ctx->Color.Blend[index].DstA;
2353      return TYPE_INT;
2354   case GL_BLEND_EQUATION_RGB:
2355      if (index >= ctx->Const.MaxDrawBuffers)
2356         goto invalid_value;
2357      if (!ctx->Extensions.ARB_draw_buffers_blend)
2358         goto invalid_enum;
2359      v->value_int = ctx->Color.Blend[index].EquationRGB;
2360      return TYPE_INT;
2361   case GL_BLEND_EQUATION_ALPHA:
2362      if (index >= ctx->Const.MaxDrawBuffers)
2363         goto invalid_value;
2364      if (!ctx->Extensions.ARB_draw_buffers_blend)
2365         goto invalid_enum;
2366      v->value_int = ctx->Color.Blend[index].EquationA;
2367      return TYPE_INT;
2368
2369   case GL_COLOR_WRITEMASK:
2370      if (index >= ctx->Const.MaxDrawBuffers)
2371         goto invalid_value;
2372      if (!ctx->Extensions.EXT_draw_buffers2)
2373         goto invalid_enum;
2374      v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 0);
2375      v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 1);
2376      v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 2);
2377      v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 3);
2378      return TYPE_INT_4;
2379
2380   case GL_SCISSOR_BOX:
2381      if (index >= ctx->Const.MaxViewports)
2382         goto invalid_value;
2383      v->value_int_4[0] = ctx->Scissor.ScissorArray[index].X;
2384      v->value_int_4[1] = ctx->Scissor.ScissorArray[index].Y;
2385      v->value_int_4[2] = ctx->Scissor.ScissorArray[index].Width;
2386      v->value_int_4[3] = ctx->Scissor.ScissorArray[index].Height;
2387      return TYPE_INT_4;
2388
2389   case GL_WINDOW_RECTANGLE_EXT:
2390      if (!ctx->Extensions.EXT_window_rectangles)
2391         goto invalid_enum;
2392      if (index >= ctx->Const.MaxWindowRectangles)
2393         goto invalid_value;
2394      v->value_int_4[0] = ctx->Scissor.WindowRects[index].X;
2395      v->value_int_4[1] = ctx->Scissor.WindowRects[index].Y;
2396      v->value_int_4[2] = ctx->Scissor.WindowRects[index].Width;
2397      v->value_int_4[3] = ctx->Scissor.WindowRects[index].Height;
2398      return TYPE_INT_4;
2399
2400   case GL_VIEWPORT:
2401      if (index >= ctx->Const.MaxViewports)
2402         goto invalid_value;
2403      v->value_float_4[0] = ctx->ViewportArray[index].X;
2404      v->value_float_4[1] = ctx->ViewportArray[index].Y;
2405      v->value_float_4[2] = ctx->ViewportArray[index].Width;
2406      v->value_float_4[3] = ctx->ViewportArray[index].Height;
2407      return TYPE_FLOAT_4;
2408
2409   case GL_DEPTH_RANGE:
2410      if (index >= ctx->Const.MaxViewports)
2411         goto invalid_value;
2412      v->value_double_2[0] = ctx->ViewportArray[index].Near;
2413      v->value_double_2[1] = ctx->ViewportArray[index].Far;
2414      return TYPE_DOUBLEN_2;
2415
2416   case GL_TRANSFORM_FEEDBACK_BUFFER_START:
2417      if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2418         goto invalid_value;
2419      if (!ctx->Extensions.EXT_transform_feedback)
2420         goto invalid_enum;
2421      v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
2422      return TYPE_INT64;
2423
2424   case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
2425      if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2426         goto invalid_value;
2427      if (!ctx->Extensions.EXT_transform_feedback)
2428         goto invalid_enum;
2429      v->value_int64
2430         = ctx->TransformFeedback.CurrentObject->RequestedSize[index];
2431      return TYPE_INT64;
2432
2433   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2434      if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2435         goto invalid_value;
2436      if (!ctx->Extensions.EXT_transform_feedback)
2437         goto invalid_enum;
2438      v->value_int = ctx->TransformFeedback.CurrentObject->BufferNames[index];
2439      return TYPE_INT;
2440
2441   case GL_UNIFORM_BUFFER_BINDING:
2442      if (index >= ctx->Const.MaxUniformBufferBindings)
2443         goto invalid_value;
2444      if (!ctx->Extensions.ARB_uniform_buffer_object)
2445         goto invalid_enum;
2446      v->value_int = ctx->UniformBufferBindings[index].BufferObject->Name;
2447      return TYPE_INT;
2448
2449   case GL_UNIFORM_BUFFER_START:
2450      if (index >= ctx->Const.MaxUniformBufferBindings)
2451         goto invalid_value;
2452      if (!ctx->Extensions.ARB_uniform_buffer_object)
2453         goto invalid_enum;
2454      v->value_int = ctx->UniformBufferBindings[index].Offset < 0 ? 0 :
2455                     ctx->UniformBufferBindings[index].Offset;
2456      return TYPE_INT;
2457
2458   case GL_UNIFORM_BUFFER_SIZE:
2459      if (index >= ctx->Const.MaxUniformBufferBindings)
2460         goto invalid_value;
2461      if (!ctx->Extensions.ARB_uniform_buffer_object)
2462         goto invalid_enum;
2463      v->value_int = ctx->UniformBufferBindings[index].Size < 0 ? 0 :
2464                     ctx->UniformBufferBindings[index].Size;
2465      return TYPE_INT;
2466
2467   /* ARB_shader_storage_buffer_object */
2468   case GL_SHADER_STORAGE_BUFFER_BINDING:
2469      if (!ctx->Extensions.ARB_shader_storage_buffer_object)
2470         goto invalid_enum;
2471      if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2472         goto invalid_value;
2473      v->value_int = ctx->ShaderStorageBufferBindings[index].BufferObject->Name;
2474      return TYPE_INT;
2475
2476   case GL_SHADER_STORAGE_BUFFER_START:
2477      if (!ctx->Extensions.ARB_shader_storage_buffer_object)
2478         goto invalid_enum;
2479      if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2480         goto invalid_value;
2481      v->value_int = ctx->ShaderStorageBufferBindings[index].Offset < 0 ? 0 :
2482                     ctx->ShaderStorageBufferBindings[index].Offset;
2483      return TYPE_INT;
2484
2485   case GL_SHADER_STORAGE_BUFFER_SIZE:
2486      if (!ctx->Extensions.ARB_shader_storage_buffer_object)
2487         goto invalid_enum;
2488      if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2489         goto invalid_value;
2490      v->value_int = ctx->ShaderStorageBufferBindings[index].Size < 0 ? 0 :
2491                     ctx->ShaderStorageBufferBindings[index].Size;
2492      return TYPE_INT;
2493
2494   /* ARB_texture_multisample / GL3.2 */
2495   case GL_SAMPLE_MASK_VALUE:
2496      if (index != 0)
2497         goto invalid_value;
2498      if (!ctx->Extensions.ARB_texture_multisample)
2499         goto invalid_enum;
2500      v->value_int = ctx->Multisample.SampleMaskValue;
2501      return TYPE_INT;
2502
2503   case GL_ATOMIC_COUNTER_BUFFER_BINDING:
2504      if (!ctx->Extensions.ARB_shader_atomic_counters)
2505         goto invalid_enum;
2506      if (index >= ctx->Const.MaxAtomicBufferBindings)
2507         goto invalid_value;
2508      v->value_int = ctx->AtomicBufferBindings[index].BufferObject->Name;
2509      return TYPE_INT;
2510
2511   case GL_ATOMIC_COUNTER_BUFFER_START:
2512      if (!ctx->Extensions.ARB_shader_atomic_counters)
2513         goto invalid_enum;
2514      if (index >= ctx->Const.MaxAtomicBufferBindings)
2515         goto invalid_value;
2516      v->value_int64 = ctx->AtomicBufferBindings[index].Offset < 0 ? 0 :
2517                       ctx->AtomicBufferBindings[index].Offset;
2518      return TYPE_INT64;
2519
2520   case GL_ATOMIC_COUNTER_BUFFER_SIZE:
2521      if (!ctx->Extensions.ARB_shader_atomic_counters)
2522         goto invalid_enum;
2523      if (index >= ctx->Const.MaxAtomicBufferBindings)
2524         goto invalid_value;
2525      v->value_int64 = ctx->AtomicBufferBindings[index].Size < 0 ? 0 :
2526                       ctx->AtomicBufferBindings[index].Size;
2527      return TYPE_INT64;
2528
2529   case GL_VERTEX_BINDING_DIVISOR:
2530      if ((!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_instanced_arrays) &&
2531          !_mesa_is_gles31(ctx))
2532          goto invalid_enum;
2533      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2534          goto invalid_value;
2535      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor;
2536      return TYPE_INT;
2537
2538   case GL_VERTEX_BINDING_OFFSET:
2539      if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles31(ctx))
2540          goto invalid_enum;
2541      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2542          goto invalid_value;
2543      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
2544      return TYPE_INT;
2545
2546   case GL_VERTEX_BINDING_STRIDE:
2547      if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles31(ctx))
2548          goto invalid_enum;
2549      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2550          goto invalid_value;
2551      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].Stride;
2552      return TYPE_INT;
2553
2554   case GL_VERTEX_BINDING_BUFFER:
2555      if (ctx->API == API_OPENGLES2 && ctx->Version < 31)
2556         goto invalid_enum;
2557      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2558         goto invalid_value;
2559      v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name;
2560      return TYPE_INT;
2561
2562   /* ARB_shader_image_load_store */
2563   case GL_IMAGE_BINDING_NAME: {
2564      struct gl_texture_object *t;
2565
2566      if (!ctx->Extensions.ARB_shader_image_load_store)
2567         goto invalid_enum;
2568      if (index >= ctx->Const.MaxImageUnits)
2569         goto invalid_value;
2570
2571      t = ctx->ImageUnits[index].TexObj;
2572      v->value_int = (t ? t->Name : 0);
2573      return TYPE_INT;
2574   }
2575
2576   case GL_IMAGE_BINDING_LEVEL:
2577      if (!ctx->Extensions.ARB_shader_image_load_store)
2578         goto invalid_enum;
2579      if (index >= ctx->Const.MaxImageUnits)
2580         goto invalid_value;
2581
2582      v->value_int = ctx->ImageUnits[index].Level;
2583      return TYPE_INT;
2584
2585   case GL_IMAGE_BINDING_LAYERED:
2586      if (!ctx->Extensions.ARB_shader_image_load_store)
2587         goto invalid_enum;
2588      if (index >= ctx->Const.MaxImageUnits)
2589         goto invalid_value;
2590
2591      v->value_int = ctx->ImageUnits[index].Layered;
2592      return TYPE_INT;
2593
2594   case GL_IMAGE_BINDING_LAYER:
2595      if (!ctx->Extensions.ARB_shader_image_load_store)
2596         goto invalid_enum;
2597      if (index >= ctx->Const.MaxImageUnits)
2598         goto invalid_value;
2599
2600      v->value_int = ctx->ImageUnits[index].Layer;
2601      return TYPE_INT;
2602
2603   case GL_IMAGE_BINDING_ACCESS:
2604      if (!ctx->Extensions.ARB_shader_image_load_store)
2605         goto invalid_enum;
2606      if (index >= ctx->Const.MaxImageUnits)
2607         goto invalid_value;
2608
2609      v->value_int = ctx->ImageUnits[index].Access;
2610      return TYPE_INT;
2611
2612   case GL_IMAGE_BINDING_FORMAT:
2613      if (!ctx->Extensions.ARB_shader_image_load_store)
2614         goto invalid_enum;
2615      if (index >= ctx->Const.MaxImageUnits)
2616         goto invalid_value;
2617
2618      v->value_int = ctx->ImageUnits[index].Format;
2619      return TYPE_INT;
2620
2621   /* ARB_direct_state_access */
2622   case GL_TEXTURE_BINDING_1D:
2623   case GL_TEXTURE_BINDING_1D_ARRAY:
2624   case GL_TEXTURE_BINDING_2D:
2625   case GL_TEXTURE_BINDING_2D_ARRAY:
2626   case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2627   case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2628   case GL_TEXTURE_BINDING_3D:
2629   case GL_TEXTURE_BINDING_BUFFER:
2630   case GL_TEXTURE_BINDING_CUBE_MAP:
2631   case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2632   case GL_TEXTURE_BINDING_RECTANGLE: {
2633      int target;
2634
2635      if (ctx->API != API_OPENGL_CORE)
2636         goto invalid_enum;
2637      target = tex_binding_to_index(ctx, pname);
2638      if (target < 0)
2639         goto invalid_enum;
2640      if (index >= _mesa_max_tex_unit(ctx))
2641         goto invalid_value;
2642
2643      v->value_int = ctx->Texture.Unit[index].CurrentTex[target]->Name;
2644      return TYPE_INT;
2645   }
2646
2647   case GL_SAMPLER_BINDING: {
2648      struct gl_sampler_object *samp;
2649
2650      if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 33)
2651         goto invalid_enum;
2652      if (index >= _mesa_max_tex_unit(ctx))
2653         goto invalid_value;
2654
2655      samp = ctx->Texture.Unit[index].Sampler;
2656      v->value_int = samp ? samp->Name : 0;
2657      return TYPE_INT;
2658   }
2659
2660   case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
2661      if (!_mesa_has_compute_shaders(ctx))
2662         goto invalid_enum;
2663      if (index >= 3)
2664         goto invalid_value;
2665      v->value_int = ctx->Const.MaxComputeWorkGroupCount[index];
2666      return TYPE_INT;
2667
2668   case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
2669      if (!_mesa_has_compute_shaders(ctx))
2670         goto invalid_enum;
2671      if (index >= 3)
2672         goto invalid_value;
2673      v->value_int = ctx->Const.MaxComputeWorkGroupSize[index];
2674      return TYPE_INT;
2675
2676   /* ARB_compute_variable_group_size */
2677   case GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB:
2678      if (!ctx->Extensions.ARB_compute_variable_group_size)
2679         goto invalid_enum;
2680      if (index >= 3)
2681         goto invalid_value;
2682      v->value_int = ctx->Const.MaxComputeVariableGroupSize[index];
2683      return TYPE_INT;
2684
2685   /* GL_EXT_external_objects */
2686   case GL_NUM_DEVICE_UUIDS_EXT:
2687      v->value_int = 1;
2688      return TYPE_INT;
2689   case GL_DRIVER_UUID_EXT:
2690      if (index >= 1)
2691         goto invalid_value;
2692      _mesa_get_driver_uuid(ctx, v->value_int_4);
2693      return TYPE_INT_4;
2694   case GL_DEVICE_UUID_EXT:
2695      if (index >= 1)
2696         goto invalid_value;
2697      _mesa_get_device_uuid(ctx, v->value_int_4);
2698      return TYPE_INT_4;
2699   }
2700
2701 invalid_enum:
2702   _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
2703               _mesa_enum_to_string(pname));
2704   return TYPE_INVALID;
2705 invalid_value:
2706   _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
2707               _mesa_enum_to_string(pname));
2708   return TYPE_INVALID;
2709}
2710
2711void GLAPIENTRY
2712_mesa_GetBooleani_v( GLenum pname, GLuint index, GLboolean *params )
2713{
2714   union value v;
2715   enum value_type type =
2716      find_value_indexed("glGetBooleani_v", pname, index, &v);
2717
2718   switch (type) {
2719   case TYPE_INT:
2720   case TYPE_UINT:
2721      params[0] = INT_TO_BOOLEAN(v.value_int);
2722      break;
2723   case TYPE_INT_4:
2724   case TYPE_UINT_4:
2725      params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
2726      params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
2727      params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
2728      params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
2729      break;
2730   case TYPE_INT64:
2731      params[0] = INT64_TO_BOOLEAN(v.value_int64);
2732      break;
2733   default:
2734      ; /* nothing - GL error was recorded */
2735   }
2736}
2737
2738void GLAPIENTRY
2739_mesa_GetIntegeri_v( GLenum pname, GLuint index, GLint *params )
2740{
2741   union value v;
2742   enum value_type type =
2743      find_value_indexed("glGetIntegeri_v", pname, index, &v);
2744
2745   switch (type) {
2746   case TYPE_FLOAT_4:
2747   case TYPE_FLOATN_4:
2748      params[3] = IROUND(v.value_float_4[3]);
2749   case TYPE_FLOAT_3:
2750   case TYPE_FLOATN_3:
2751      params[2] = IROUND(v.value_float_4[2]);
2752   case TYPE_FLOAT_2:
2753   case TYPE_FLOATN_2:
2754      params[1] = IROUND(v.value_float_4[1]);
2755   case TYPE_FLOAT:
2756   case TYPE_FLOATN:
2757      params[0] = IROUND(v.value_float_4[0]);
2758      break;
2759
2760   case TYPE_DOUBLEN_2:
2761      params[1] = IROUND(v.value_double_2[1]);
2762   case TYPE_DOUBLEN:
2763      params[0] = IROUND(v.value_double_2[0]);
2764      break;
2765
2766   case TYPE_INT:
2767   case TYPE_UINT:
2768      params[0] = v.value_int;
2769      break;
2770   case TYPE_INT_4:
2771   case TYPE_UINT_4:
2772      params[0] = v.value_int_4[0];
2773      params[1] = v.value_int_4[1];
2774      params[2] = v.value_int_4[2];
2775      params[3] = v.value_int_4[3];
2776      break;
2777   case TYPE_INT64:
2778      params[0] = INT64_TO_INT(v.value_int64);
2779      break;
2780   default:
2781      ; /* nothing - GL error was recorded */
2782   }
2783}
2784
2785void GLAPIENTRY
2786_mesa_GetInteger64i_v( GLenum pname, GLuint index, GLint64 *params )
2787{
2788   union value v;
2789   enum value_type type =
2790      find_value_indexed("glGetInteger64i_v", pname, index, &v);
2791
2792   switch (type) {
2793   case TYPE_INT:
2794      params[0] = v.value_int;
2795      break;
2796   case TYPE_INT_4:
2797      params[0] = v.value_int_4[0];
2798      params[1] = v.value_int_4[1];
2799      params[2] = v.value_int_4[2];
2800      params[3] = v.value_int_4[3];
2801      break;
2802   case TYPE_UINT:
2803      params[0] = (GLuint) v.value_int;
2804      break;
2805   case TYPE_UINT_4:
2806      params[0] = (GLuint) v.value_int_4[0];
2807      params[1] = (GLuint) v.value_int_4[1];
2808      params[2] = (GLuint) v.value_int_4[2];
2809      params[3] = (GLuint) v.value_int_4[3];
2810      break;
2811   case TYPE_INT64:
2812      params[0] = v.value_int64;
2813      break;
2814   default:
2815      ; /* nothing - GL error was recorded */
2816   }
2817}
2818
2819void GLAPIENTRY
2820_mesa_GetFloati_v(GLenum pname, GLuint index, GLfloat *params)
2821{
2822   int i;
2823   GLmatrix *m;
2824   union value v;
2825   enum value_type type =
2826      find_value_indexed("glGetFloati_v", pname, index, &v);
2827
2828   switch (type) {
2829   case TYPE_FLOAT_4:
2830   case TYPE_FLOATN_4:
2831      params[3] = v.value_float_4[3];
2832   case TYPE_FLOAT_3:
2833   case TYPE_FLOATN_3:
2834      params[2] = v.value_float_4[2];
2835   case TYPE_FLOAT_2:
2836   case TYPE_FLOATN_2:
2837      params[1] = v.value_float_4[1];
2838   case TYPE_FLOAT:
2839   case TYPE_FLOATN:
2840      params[0] = v.value_float_4[0];
2841      break;
2842
2843   case TYPE_DOUBLEN_2:
2844      params[1] = (GLfloat) v.value_double_2[1];
2845   case TYPE_DOUBLEN:
2846      params[0] = (GLfloat) v.value_double_2[0];
2847      break;
2848
2849   case TYPE_INT_4:
2850      params[3] = (GLfloat) v.value_int_4[3];
2851   case TYPE_INT_3:
2852      params[2] = (GLfloat) v.value_int_4[2];
2853   case TYPE_INT_2:
2854   case TYPE_ENUM_2:
2855      params[1] = (GLfloat) v.value_int_4[1];
2856   case TYPE_INT:
2857   case TYPE_ENUM:
2858   case TYPE_ENUM16:
2859      params[0] = (GLfloat) v.value_int_4[0];
2860      break;
2861
2862   case TYPE_INT_N:
2863      for (i = 0; i < v.value_int_n.n; i++)
2864         params[i] = (GLfloat) v.value_int_n.ints[i];
2865      break;
2866
2867   case TYPE_UINT_4:
2868      params[3] = (GLfloat) ((GLuint) v.value_int_4[3]);
2869   case TYPE_UINT_3:
2870      params[2] = (GLfloat) ((GLuint) v.value_int_4[2]);
2871   case TYPE_UINT_2:
2872      params[1] = (GLfloat) ((GLuint) v.value_int_4[1]);
2873   case TYPE_UINT:
2874      params[0] = (GLfloat) ((GLuint) v.value_int_4[0]);
2875      break;
2876
2877   case TYPE_INT64:
2878      params[0] = (GLfloat) v.value_int64;
2879      break;
2880
2881   case TYPE_BOOLEAN:
2882      params[0] = BOOLEAN_TO_FLOAT(v.value_bool);
2883      break;
2884
2885   case TYPE_UBYTE:
2886      params[0] = (GLfloat) v.value_ubyte;
2887      break;
2888
2889   case TYPE_SHORT:
2890      params[0] = (GLfloat) v.value_short;
2891      break;
2892
2893   case TYPE_MATRIX:
2894      m = *(GLmatrix **) &v;
2895      for (i = 0; i < 16; i++)
2896         params[i] = m->m[i];
2897      break;
2898
2899   case TYPE_MATRIX_T:
2900      m = *(GLmatrix **) &v;
2901      for (i = 0; i < 16; i++)
2902         params[i] = m->m[transpose[i]];
2903      break;
2904
2905   default:
2906      ;
2907   }
2908}
2909
2910void GLAPIENTRY
2911_mesa_GetDoublei_v(GLenum pname, GLuint index, GLdouble *params)
2912{
2913   int i;
2914   GLmatrix *m;
2915   union value v;
2916   enum value_type type =
2917      find_value_indexed("glGetDoublei_v", pname, index, &v);
2918
2919   switch (type) {
2920   case TYPE_FLOAT_4:
2921   case TYPE_FLOATN_4:
2922      params[3] = (GLdouble) v.value_float_4[3];
2923   case TYPE_FLOAT_3:
2924   case TYPE_FLOATN_3:
2925      params[2] = (GLdouble) v.value_float_4[2];
2926   case TYPE_FLOAT_2:
2927   case TYPE_FLOATN_2:
2928      params[1] = (GLdouble) v.value_float_4[1];
2929   case TYPE_FLOAT:
2930   case TYPE_FLOATN:
2931      params[0] = (GLdouble) v.value_float_4[0];
2932      break;
2933
2934   case TYPE_DOUBLEN_2:
2935      params[1] = v.value_double_2[1];
2936   case TYPE_DOUBLEN:
2937      params[0] = v.value_double_2[0];
2938      break;
2939
2940   case TYPE_INT_4:
2941      params[3] = (GLdouble) v.value_int_4[3];
2942   case TYPE_INT_3:
2943      params[2] = (GLdouble) v.value_int_4[2];
2944   case TYPE_INT_2:
2945   case TYPE_ENUM_2:
2946      params[1] = (GLdouble) v.value_int_4[1];
2947   case TYPE_INT:
2948   case TYPE_ENUM:
2949   case TYPE_ENUM16:
2950      params[0] = (GLdouble) v.value_int_4[0];
2951      break;
2952
2953   case TYPE_INT_N:
2954      for (i = 0; i < v.value_int_n.n; i++)
2955         params[i] = (GLdouble) v.value_int_n.ints[i];
2956      break;
2957
2958   case TYPE_UINT_4:
2959      params[3] = (GLdouble) ((GLuint) v.value_int_4[3]);
2960   case TYPE_UINT_3:
2961      params[2] = (GLdouble) ((GLuint) v.value_int_4[2]);
2962   case TYPE_UINT_2:
2963      params[1] = (GLdouble) ((GLuint) v.value_int_4[1]);
2964   case TYPE_UINT:
2965      params[0] = (GLdouble) ((GLuint) v.value_int_4[0]);
2966      break;
2967
2968   case TYPE_INT64:
2969      params[0] = (GLdouble) v.value_int64;
2970      break;
2971
2972   case TYPE_BOOLEAN:
2973      params[0] = (GLdouble) BOOLEAN_TO_FLOAT(v.value_bool);
2974      break;
2975
2976   case TYPE_UBYTE:
2977      params[0] = (GLdouble) v.value_ubyte;
2978      break;
2979
2980   case TYPE_SHORT:
2981      params[0] = (GLdouble) v.value_short;
2982      break;
2983
2984   case TYPE_MATRIX:
2985      m = *(GLmatrix **) &v;
2986      for (i = 0; i < 16; i++)
2987         params[i] = (GLdouble) m->m[i];
2988      break;
2989
2990   case TYPE_MATRIX_T:
2991      m = *(GLmatrix **) &v;
2992      for (i = 0; i < 16; i++)
2993         params[i] = (GLdouble) m->m[transpose[i]];
2994      break;
2995
2996   default:
2997      ;
2998   }
2999}
3000
3001void GLAPIENTRY
3002_mesa_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
3003{
3004   GLsizei size;
3005   union value v;
3006   enum value_type type;
3007   const char *func = "glGetUnsignedBytei_vEXT";
3008
3009   GET_CURRENT_CONTEXT(ctx);
3010
3011   if (!ctx->Extensions.EXT_memory_object) {
3012      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
3013      return;
3014   }
3015
3016   type = find_value_indexed(func, target, index, &v);
3017   size = get_value_size(type, &v);
3018   if (size <= 0) {
3019      _mesa_problem(ctx, "invalid value type in GetUnsignedBytei_vEXT()");
3020   }
3021
3022   switch (type) {
3023   case TYPE_UINT:
3024   case TYPE_INT:
3025   case TYPE_INT_2:
3026   case TYPE_UINT_2:
3027   case TYPE_INT_3:
3028   case TYPE_UINT_3:
3029   case TYPE_INT_4:
3030   case TYPE_UINT_4:
3031   case TYPE_INT64:
3032   case TYPE_ENUM16:
3033   case TYPE_ENUM:
3034   case TYPE_ENUM_2:
3035   case TYPE_BOOLEAN:
3036   case TYPE_UBYTE:
3037   case TYPE_SHORT:
3038   case TYPE_FLOAT:
3039   case TYPE_FLOATN:
3040   case TYPE_FLOAT_2:
3041   case TYPE_FLOATN_2:
3042   case TYPE_FLOAT_3:
3043   case TYPE_FLOATN_3:
3044   case TYPE_FLOAT_4:
3045   case TYPE_FLOATN_4:
3046   case TYPE_FLOAT_8:
3047   case TYPE_DOUBLEN:
3048   case TYPE_DOUBLEN_2:
3049   case TYPE_MATRIX:
3050   case TYPE_MATRIX_T:
3051      memcpy(data, &v.value_int, size);
3052      break;
3053   case TYPE_INT_N:
3054      memcpy(data, &v.value_int_n.ints, size);
3055      break;
3056   default:
3057      break; /* nothing - GL error was recorded */
3058   }
3059}
3060
3061void GLAPIENTRY
3062_mesa_GetFixedv(GLenum pname, GLfixed *params)
3063{
3064   const struct value_desc *d;
3065   union value v;
3066   GLmatrix *m;
3067   int shift, i;
3068   void *p;
3069
3070   d = find_value("glGetDoublev", pname, &p, &v);
3071   switch (d->type) {
3072   case TYPE_INVALID:
3073      break;
3074   case TYPE_CONST:
3075      params[0] = INT_TO_FIXED(d->offset);
3076      break;
3077
3078   case TYPE_FLOAT_4:
3079   case TYPE_FLOATN_4:
3080      params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
3081   case TYPE_FLOAT_3:
3082   case TYPE_FLOATN_3:
3083      params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
3084   case TYPE_FLOAT_2:
3085   case TYPE_FLOATN_2:
3086      params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
3087   case TYPE_FLOAT:
3088   case TYPE_FLOATN:
3089      params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
3090      break;
3091
3092   case TYPE_DOUBLEN_2:
3093      params[1] = FLOAT_TO_FIXED(((GLdouble *) p)[1]);
3094   case TYPE_DOUBLEN:
3095      params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
3096      break;
3097
3098   case TYPE_INT_4:
3099   case TYPE_UINT_4:
3100      params[3] = INT_TO_FIXED(((GLint *) p)[3]);
3101   case TYPE_INT_3:
3102   case TYPE_UINT_3:
3103      params[2] = INT_TO_FIXED(((GLint *) p)[2]);
3104   case TYPE_INT_2:
3105   case TYPE_UINT_2:
3106   case TYPE_ENUM_2:
3107      params[1] = INT_TO_FIXED(((GLint *) p)[1]);
3108   case TYPE_INT:
3109   case TYPE_UINT:
3110   case TYPE_ENUM:
3111      params[0] = INT_TO_FIXED(((GLint *) p)[0]);
3112      break;
3113
3114   case TYPE_ENUM16:
3115      params[0] = INT_TO_FIXED((GLint)(((GLenum16 *) p)[0]));
3116      break;
3117
3118   case TYPE_INT_N:
3119      for (i = 0; i < v.value_int_n.n; i++)
3120         params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
3121      break;
3122
3123   case TYPE_INT64:
3124      params[0] = ((GLint64 *) p)[0];
3125      break;
3126
3127   case TYPE_BOOLEAN:
3128      params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
3129      break;
3130
3131   case TYPE_UBYTE:
3132      params[0] = INT_TO_FIXED(((GLubyte *) p)[0]);
3133      break;
3134
3135   case TYPE_SHORT:
3136      params[0] = INT_TO_FIXED(((GLshort *) p)[0]);
3137      break;
3138
3139   case TYPE_MATRIX:
3140      m = *(GLmatrix **) p;
3141      for (i = 0; i < 16; i++)
3142         params[i] = FLOAT_TO_FIXED(m->m[i]);
3143      break;
3144
3145   case TYPE_MATRIX_T:
3146      m = *(GLmatrix **) p;
3147      for (i = 0; i < 16; i++)
3148         params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
3149      break;
3150
3151   case TYPE_BIT_0:
3152   case TYPE_BIT_1:
3153   case TYPE_BIT_2:
3154   case TYPE_BIT_3:
3155   case TYPE_BIT_4:
3156   case TYPE_BIT_5:
3157   case TYPE_BIT_6:
3158   case TYPE_BIT_7:
3159      shift = d->type - TYPE_BIT_0;
3160      params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);
3161      break;
3162   }
3163}
3164