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