deleted file mode 100644
@@ -1,86 +0,0 @@
-From de01f17a2cb88dc5ff53cc321342b888c33b120a Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Lo=C3=AFc=20Minier?= <lool@dooz.org>
-Date: Thu, 11 Feb 2010 17:42:33 +0100
-Subject: [PATCH] Detect and use GCC atomic builtins for locking
-
----
- configure | 17 +++++++++++++++++
- qemu-lock.h | 13 +++++++++++++
- 2 files changed, 30 insertions(+), 0 deletions(-)
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/configure
-===================================================================
---- qemu-0.14.0.orig/configure
-+++ qemu-0.14.0/configure
-@@ -2243,6 +2243,20 @@ fi
- ##########################################
-
- ##########################################
-+# check if we have gcc atomic built-ins
-+gcc_atomic_builtins=no
-+cat > $TMPC << EOF
-+int main(void) {
-+ int i;
-+ __sync_lock_test_and_set(&i, 1);
-+ __sync_lock_release(&i);
-+}
-+EOF
-+if compile_prog "" ""; then
-+ gcc_atomic_builtins=yes
-+fi
-+
-+##########################################
- # check if we have fdatasync
-
- fdatasync=no
-@@ -2731,6 +2745,9 @@ fi
- if test "$gcc_attribute_warn_unused_result" = "yes" ; then
- echo "CONFIG_GCC_ATTRIBUTE_WARN_UNUSED_RESULT=y" >> $config_host_mak
- fi
-+if test "$gcc_atomic_builtins" = "yes" ; then
-+ echo "CONFIG_GCC_ATOMIC_BUILTINS=y" >> $config_host_mak
-+fi
- if test "$fdatasync" = "yes" ; then
- echo "CONFIG_FDATASYNC=y" >> $config_host_mak
- fi
-Index: qemu-0.14.0/qemu-lock.h
-===================================================================
---- qemu-0.14.0.orig/qemu-lock.h
-+++ qemu-0.14.0/qemu-lock.h
-@@ -33,6 +33,14 @@
-
- #else
-
-+#ifdef CONFIG_GCC_ATOMIC_BUILTINS
-+typedef int spinlock_t;
-+
-+#define SPIN_LOCK_UNLOCKED 0
-+
-+#define resetlock(p) __sync_lock_release((p))
-+#else /* CONFIG_GCC_ATOMIC_BUILTINS */
-+
- #if defined(__hppa__)
-
- typedef int spinlock_t[4];
-@@ -56,7 +64,11 @@ static inline void resetlock (spinlock_t
- }
-
- #endif
-+#endif /* !CONFIG_GCC_ATOMIC_BUILTINS */
-
-+#ifdef CONFIG_GCC_ATOMIC_BUILTINS
-+#define testandset(p) __sync_lock_test_and_set((p), 1)
-+#else /* CONFIG_GCC_ATOMIC_BUILTINS */
- #if defined(_ARCH_PPC)
- static inline int testandset (int *p)
- {
-@@ -213,6 +225,7 @@ static inline int testandset (int *p)
- #else
- #error unimplemented CPU support
- #endif
-+#endif /* !CONFIG_GCC_ATOMIC_BUILTINS */
-
- #if defined(CONFIG_USER_ONLY)
- static inline void spin_lock(spinlock_t *lock)
deleted file mode 100644
@@ -1,30 +0,0 @@
-After kernel commit:
-
-http://git.yoctoproject.org/cgit/cgit.cgi/linux-yocto-3.0/commit/?h=meta&id=9728c1b6a724daefc413b44e10253cdbb5e06d08
-
-It appears that the emulated colours in qemu are incorrect and that
-the red and blue channels are reversed. This patch reverses that logic
-so the colours are correctly displayed on the versatile platform which
-doesn't support the BGR bit.
-
-RP 16/9/2011
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/hw/pl110.c
-===================================================================
---- qemu-0.14.0.orig/hw/pl110.c 2011-09-16 14:45:34.228668514 +0100
-+++ qemu-0.14.0/hw/pl110.c 2011-09-16 15:17:22.458671206 +0100
-@@ -141,7 +141,11 @@
- fprintf(stderr, "pl110: Bad color depth\n");
- exit(1);
- }
-- if (s->cr & PL110_CR_BGR)
-+
-+ if (s->versatile && s->bpp == BPP_16)
-+ /* Code assumes BPP_16 == 565 and BGR is never set on the versatile in 565 mode */
-+ bpp_offset = 0;
-+ else if (s->cr & PL110_CR_BGR)
- bpp_offset = 0;
- else
- bpp_offset = 18;
deleted file mode 100644
@@ -1,55 +0,0 @@
-Enable i386-linux-user
-
-Signed-off-by: Zhai Edwin <edwin.zhai@intel.com>
-
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -78,8 +78,13 @@ ifeq ($(TARGET_BASE_ARCH), i386)
- libobj-y += cpuid.o
- endif
- libobj-$(CONFIG_NEED_MMU) += mmu.o
-+ifndef CONFIG_LINUX_USER
- libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
- libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o
-+else
-+libobj-$(TARGET_I386) += dummygl.o
-+libobj-$(TARGET_X86_64) += dummygl.o
-+endif #CONFIG_LINUX_USER
- libobj-$(TARGET_ARM) += dummygl.o
- libobj-$(TARGET_MIPS) += dummygl.o
- libobj-$(TARGET_PPC) += dummygl.o
-Index: qemu-0.14.0/target-i386/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/dummygl.c
-@@ -0,0 +1,26 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-+
-+void helper_opengl(void)
-+{
-+}
deleted file mode 100644
@@ -1,39 +0,0 @@
-From c313f89c33217ac0e471554dace2144718f86669 Mon Sep 17 00:00:00 2001
-From: Martin Jansa <Martin.Jansa@gmail.com>
-Date: Thu, 13 May 2010 12:23:40 +0200
-Subject: [PATCH] linux-user: use default mmap_min_addr 65536 when /proc/sys/vm/mmap_min_addr cannot be read
-
-* 65536 is default at least for ubuntu and fedora.
----
- linux-user/main.c | 5 +++++
- 1 files changed, 5 insertions(+), 0 deletions(-)
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/linux-user/main.c
-===================================================================
---- qemu-0.14.0.orig/linux-user/main.c
-+++ qemu-0.14.0/linux-user/main.c
-@@ -36,6 +36,7 @@
- #include "envlist.h"
-
- #define DEBUG_LOGFILE "/tmp/qemu.log"
-+#define MMAP_MIN_ADDR_DEFAULT 65536
-
- char *exec_path;
-
-@@ -3010,8 +3011,14 @@ int main(int argc, char **argv, char **e
- if (fscanf(fp, "%lu", &tmp) == 1) {
- mmap_min_addr = tmp;
- qemu_log("host mmap_min_addr=0x%lx\n", mmap_min_addr);
-+ } else {
-+ qemu_log("cannot read value from /proc/sys/vm/mmap_min_addr, assuming %d\n", MMAP_MIN_ADDR_DEFAULT);
-+ mmap_min_addr = MMAP_MIN_ADDR_DEFAULT;
- }
- fclose(fp);
-+ } else {
-+ qemu_log("cannot open /proc/sys/vm/mmap_min_addr for reading, assuming %d\n", MMAP_MIN_ADDR_DEFAULT);
-+ mmap_min_addr = MMAP_MIN_ADDR_DEFAULT;
- }
- }
-
deleted file mode 100644
@@ -1,22 +0,0 @@
-In native builds, qemu can fail to find zlib development files in the native
-sysroot and the build machine might not have zlib-dev packages installed.
-
-Add CFLAGS to qemu's CFLAGS which in the native case means BUILD_CFLAGS are
-added and files in the sysroot can be found.
-
-Patch from Paul Eggleton, Comments by RP 28/11/10
-
-Upstream-Status: Inappropriate [embedded specific]
-
-Index: qemu-0.14.0/configure
-===================================================================
---- qemu-0.14.0.orig/configure
-+++ qemu-0.14.0/configure
-@@ -229,6 +229,7 @@ QEMU_CFLAGS="-Wstrict-prototypes -Wredun
- QEMU_CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE $QEMU_CFLAGS"
- QEMU_CFLAGS="-D_FORTIFY_SOURCE=2 $QEMU_CFLAGS"
- QEMU_INCLUDES="-I. -I\$(SRC_PATH)"
-+QEMU_CFLAGS="$QEMU_CFLAGS $CFLAGS"
- LDFLAGS="-g $LDFLAGS"
-
- # make source path absolute
deleted file mode 100644
@@ -1,127 +0,0 @@
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -79,6 +79,12 @@ libobj-y += cpuid.o
- endif
- libobj-$(CONFIG_NEED_MMU) += mmu.o
- libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
-+libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o
-+libobj-$(TARGET_ARM) += dummygl.o
-+libobj-$(TARGET_MIPS) += dummygl.o
-+libobj-$(TARGET_MIPS64) += dummygl.o
-+libobj-$(TARGET_PPC) += dummygl.o
-+libobj-$(TARGET_SH4) += dummygl.o
- libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o
-
- libobj-y += disas.o
-Index: qemu-0.14.0/target-arm/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-arm/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-Index: qemu-0.14.0/target-mips/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-mips/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-Index: qemu-0.14.0/target-ppc/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-ppc/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-Index: qemu-0.14.0/target-sh4/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-sh4/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
deleted file mode 100644
@@ -1,15 +0,0 @@
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target 2011-04-04 12:12:19.142871742 +0100
-+++ qemu-0.14.0/Makefile.target 2011-04-04 12:12:21.772871742 +0100
-@@ -362,7 +362,7 @@
-
- monitor.o: hmp-commands.h qmp-commands.h
-
--LIBS += -lGL -lGLU
-+LIBS += -lGL
-
- $(obj-y) $(obj-$(TARGET_BASE_ARCH)-y): $(GENERATED_HEADERS)
-
deleted file mode 100644
@@ -1,18 +0,0 @@
-# This is a workaround to the crashes seen on Ubuntu. Setting info to zero
-# makes info.info.x11.display zero and avoids the calls to
-# opengl_exec_set_parent_window, one of which is crashing.
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/ui/sdl.c
-===================================================================
---- qemu-0.14.0.orig/ui/sdl.c
-+++ qemu-0.14.0/ui/sdl.c
-@@ -863,6 +863,7 @@ void sdl_display_init(DisplayState *ds,
- vi = SDL_GetVideoInfo();
- host_format = *(vi->vfmt);
-
-+ bzero(&info, sizeof(info));
- SDL_GetWMInfo(&info);
- if (info.subsystem == SDL_SYSWM_X11 && info.info.x11.display)
- opengl_exec_set_parent_window(info.info.x11.display,
deleted file mode 100644
@@ -1,22 +0,0 @@
-This patch is taken from debian. 128M is too less sometimes if distro
-with lot of packages is booted so this patch raises the default to 384M
-
-It has not been applied to upstream qemu
-
-Khem Raj <raj.khem@gmail.com>
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/vl.c
-===================================================================
---- qemu-0.14.0.orig/vl.c
-+++ qemu-0.14.0/vl.c
-@@ -168,7 +168,7 @@ int main(int argc, char **argv)
- //#define DEBUG_NET
- //#define DEBUG_SLIRP
-
--#define DEFAULT_RAM_SIZE 128
-+#define DEFAULT_RAM_SIZE 384
-
- #define MAX_VIRTIO_CONSOLES 1
-
deleted file mode 100644
@@ -1,25 +0,0 @@
-Fedora 13 switched the default behaviour of the linker to no longer
-indirectly link to required libraries (i.e. dependencies of a library
-already linked to). Therefore we need to explicitly pass the depended on
-libraries into the linker for building to work on Fedora 13.
-
-More information is available on the Fedora Wiki:
-https://fedoraproject.org/wiki/UnderstandingDSOLinkChange
-
-JL - 15/06/10
-
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -218,7 +218,7 @@ obj-$(CONFIG_REALLY_VIRTFS) += virtio-9p
- obj-y += rwhandler.o
- obj-$(CONFIG_KVM) += kvm.o kvm-all.o
- obj-$(CONFIG_NO_KVM) += kvm-stub.o
--LIBS+=-lz
-+LIBS+=-lz -lX11 -ldl
-
- QEMU_CFLAGS += $(VNC_TLS_CFLAGS)
- QEMU_CFLAGS += $(VNC_SASL_CFLAGS)
deleted file mode 100644
@@ -1,15 +0,0 @@
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile
-===================================================================
---- qemu-0.14.0.orig/Makefile
-+++ qemu-0.14.0/Makefile
-@@ -235,7 +235,7 @@ install-sysconfig:
- install: all $(if $(BUILD_DOCS),install-doc) install-sysconfig
- $(INSTALL_DIR) "$(DESTDIR)$(bindir)"
- ifneq ($(TOOLS),)
-- $(INSTALL_PROG) $(STRIP_OPT) $(TOOLS) "$(DESTDIR)$(bindir)"
-+ $(INSTALL_PROG) $(TOOLS) "$(DESTDIR)$(bindir)"
- endif
- ifneq ($(BLOBS),)
- $(INSTALL_DIR) "$(DESTDIR)$(datadir)"
deleted file mode 100644
@@ -1,43 +0,0 @@
-Upstream-Status: Inappropriate [configuration]
-
-diff -u -r qemu-0.14.0/Makefile.target qemu-0.14.0-fixed/Makefile.target
---- qemu-0.14.0/Makefile.target 2011-04-26 21:22:17.627637741 -0700
-+++ qemu-0.14.0-fixed/Makefile.target 2011-04-26 21:23:02.767637747 -0700
-@@ -82,8 +82,10 @@
- libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
- libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o
- else
-+ifdef CONFIG_SDL
- libobj-$(TARGET_I386) += dummygl.o
- libobj-$(TARGET_X86_64) += dummygl.o
-+endif
- endif #CONFIG_LINUX_USER
- libobj-$(TARGET_ARM) += dummygl.o
- libobj-$(TARGET_MIPS) += dummygl.o
-Only in qemu-0.14.0-fixed: config.log
-diff -u -r qemu-0.14.0/target-i386/helper.h qemu-0.14.0-fixed/target-i386/helper.h
---- qemu-0.14.0/target-i386/helper.h 2011-04-26 21:22:11.418637742 -0700
-+++ qemu-0.14.0-fixed/target-i386/helper.h 2011-04-26 21:23:02.539637747 -0700
-@@ -217,6 +217,9 @@
- DEF_HELPER_2(rcrq, tl, tl, tl)
- #endif
-
-+#ifdef CONFIG_SDL
- DEF_HELPER_0(opengl, void)
-+#endif
-+
-
- #include "def-helper.h"
-diff -u -r qemu-0.14.0/target-i386/translate.c qemu-0.14.0-fixed/target-i386/translate.c
---- qemu-0.14.0/target-i386/translate.c 2011-04-26 21:22:21.600637743 -0700
-+++ qemu-0.14.0-fixed/target-i386/translate.c 2011-04-26 21:23:02.538637747 -0700
-@@ -2659,7 +2659,7 @@
- static void gen_interrupt(DisasContext *s, int intno,
- target_ulong cur_eip, target_ulong next_eip)
- {
--#if !defined(CONFIG_USER_ONLY)
-+#if !defined(CONFIG_USER_ONLY) && defined(CONFIG_SDL)
- if (enable_gl && intno == 0x99) {
- gen_helper_opengl();
- return;
-
deleted file mode 100644
GIT binary patch
literal 0
HcmV?d00001
literal 4096
zcmeHJQEMDk6h4#Pn8Z}5VUd7UHb$_7oo16ZWvl_Wq7bx}RV;`Ib~1CD44Ivo&djz(
z20DZ^Sm;B1^P!YL$|?xr50Dxx<W1-=Nb#jAB1A;VL+N<VoqKm?mo4n8m<wmm`OZ1_
zyXT&{cV+<&$6*H!JMdrW!2M?){{b*MgY{|vBVVIFj`A$ZQ4}1?4fK1d-SMjkR6spQ
z_GQ*+=6p}1edN8j-n~$%zt8GvfO5${M!BlzGeJ!LBFYOW#4B+{V8!s70opWVtXD3@
zDYsT7E6WA+<uUG+56Lw@`umUh__@Kqf6n8Nx^M%7WfVF8S{METF%22NokAEuO`<ed
z!}V9WmvV;4>hcYvi`OX{&F6WBRnw|kl?KhhA=dzmNj!qa7`0aw&RpKS@@VUVz<iB3
zMpQ$|xW4%zN%nJ?dQI!dwdlD}J%p)_T~Q;N05Shf4N8(@M;Ibka{YvEauGg?vIjtA
zbqtD8FaGQiqq(Cfl+!&ZM!lezVg)+I$)>XgU6}SL_e61d_GCWQDdT+4h>0J6J|vY6
z?n%vooL{&VPxp1(X12&CZmJJ@_@6`fnCE!)^YzN9>I}3^S{w(>9Y>+QAbsI`)YLe%
zhsb^kg>uN3pwJm3OoIDU=pIs8v?nECzNOo>lb47s&EaP<^|yU5q9tpZ%W9g#!{`Jv
zr|0H!wb2^S$51#BeALr<I95i*YdC^h)=oK8XTDy_e`39s6Efd#dZB8#PUySXQy=qb
zi2XtSc~LLG(q`vgB_qvg-;s)C8L6AkMN@f2<h+bp)Cgs?d9P4!Wp?qtu*JH{JmPj=
z9X5+MwRTe6R?5lm8zJYFbLBH3ET5Y^zkF@UH=8!Po3GplAFV<2I`~fY=BxF=C+}Vd
z-|60b7yIC&+PdqT)q3&`#C`C|bJS5^Z@xl5eDtl8^${oMHJ06gIf&9&36H?r)A;V4
z#+S@==jEcgSd;QG&rb6RyBX$`vA~Dw|Jwn1zD7)T#WL6@;i|`=;hOjXG2Diyht{Ia
zU{W_tp9O(xFxw7bGO#{l!uHt`7`AJysF!?pxyc-36&9O84uw{OE$RWwxh&Ptjb*0V
zmcvvc1M`U<9+ne0ptr1=y`Obs#c{9N%v@sN>&_Cx0<&mZafTbZr#AFp1v*?A3Nlm0
zZzgj>xMKNXQ@2&xYBnqPS-@>HKdpGnx?^IqQWS)y+YFH+ToxY7u|nTegHZRwP8V}b
zSae+sEb;%K*M1#ny}qNsYkLXA5B@1?u>#SJLhH*7Xlm<8f;#-X1y`fH6W_i8$-egB
zukYdwC~E6a_+TB*MCN`S^Bz_3)<>=KiD-M`L~SkEkMBZtb6dHCdSP>WD2n&sT(mn?
z+PpV(Q@b~GE4~eH#;xQaDju($jbT{3o+O+D*Tz`w>>7;I`r2-i+`I$ItrjS_{sHo6
zTN_Ym=RSmE(Ze$(%wLGV!aq8Lpw!l&igq#Dm@1(jj;@#MaSO(y^{Eo=O`A-R1mJvJ
aoLIp7h<sDgFE5ple~0izly{QHzx@jx&XA}8
deleted file mode 100644
@@ -1,34368 +0,0 @@
-Upstream-Status: Inappropriate [other] - qemugl patch need huge changes for upstream
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -78,6 +78,7 @@ ifeq ($(TARGET_BASE_ARCH), i386)
- libobj-y += cpuid.o
- endif
- libobj-$(CONFIG_NEED_MMU) += mmu.o
-+libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
- libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o
-
- libobj-y += disas.o
-@@ -100,6 +101,21 @@ op_helper.o cpu-exec.o: QEMU_CFLAGS += $
- # cpu_signal_handler() in cpu-exec.c.
- signal.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
-
-+parse_gl_h: parse_gl_h.c
-+ $(HOST_CC) -g -o $@ $<
-+server_stub.c: parse_gl_h
-+ ./parse_gl_h
-+gl_func.h: parse_gl_h
-+ ./parse_gl_h
-+GL_CFLAGS := -Wall -g -O2 -fno-strict-aliasing
-+opengl_func.h: gl_func.h
-+helper_opengl.o: helper_opengl.c opengl_func.h server_stub.c
-+ $(CC) $(GL_CFLAGS) $(DEFINES) -c -o $@ $< -I.. -I. -I../fpu -I../target-i386 -DNEED_CPU_H
-+gl_beginend.h: ../target-i386/beginend_funcs.sh
-+ $< > $@
-+opengl_exec.o : opengl_exec.c server_stub.c gl_func.h opengl_func.h gl_beginend.h
-+ $(CC) $(GL_CFLAGS) $(DEFINES) -c -o $@ $< -I. -I../target-i386
-+
- #########################################################
- # Linux user emulator target
-
-@@ -221,6 +237,10 @@ obj-i386-y += debugcon.o multiboot.o
- obj-i386-y += pc_piix.o
- obj-i386-$(CONFIG_SPICE) += qxl.o qxl-logger.o qxl-render.o
-
-+ifeq ($(TARGET_BASE_ARCH), i386)
-+QEMU_CFLAGS += -DTARGET_OPENGL_OK
-+endif
-+
- # shared objects
- obj-ppc-y = ppc.o
- obj-ppc-y += vga.o
-@@ -331,6 +351,8 @@ main.o: QEMU_CFLAGS+=$(GPROF_CFLAGS)
-
- monitor.o: hmp-commands.h qmp-commands.h
-
-+LIBS += -lGL -lGLU
-+
- $(obj-y) $(obj-$(TARGET_BASE_ARCH)-y): $(GENERATED_HEADERS)
-
- obj-y += $(addprefix ../, $(common-obj-y))
-Index: qemu-0.14.0/hw/pixel_ops.h
-===================================================================
---- qemu-0.14.0.orig/hw/pixel_ops.h
-+++ qemu-0.14.0/hw/pixel_ops.h
-@@ -4,6 +4,12 @@ static inline unsigned int rgb_to_pixel8
- return ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
- }
-
-+static inline unsigned int rgb_to_pixel8bgr(unsigned int r, unsigned int g,
-+ unsigned int b)
-+{
-+ return ((b >> 5) << 5) | ((g >> 5) << 2) | (r >> 6);
-+}
-+
- static inline unsigned int rgb_to_pixel15(unsigned int r, unsigned int g,
- unsigned int b)
- {
-Index: qemu-0.14.0/hw/vmware_vga.c
-===================================================================
---- qemu-0.14.0.orig/hw/vmware_vga.c
-+++ qemu-0.14.0/hw/vmware_vga.c
-@@ -517,6 +517,8 @@ static inline void vmsvga_cursor_define(
-
- #define CMD(f) le32_to_cpu(s->cmd->f)
-
-+static uint32_t last_cmd;
-+
- static inline int vmsvga_fifo_length(struct vmsvga_state_s *s)
- {
- int num;
-@@ -530,11 +532,18 @@ static inline int vmsvga_fifo_length(str
-
- static inline uint32_t vmsvga_fifo_read_raw(struct vmsvga_state_s *s)
- {
-- uint32_t cmd = s->fifo[CMD(stop) >> 2];
-- s->cmd->stop = cpu_to_le32(CMD(stop) + 4);
-- if (CMD(stop) >= CMD(max))
-+ int offset = CMD(stop);
-+
-+ if (unlikely(s->cmd->next_cmd == s->cmd->stop)) {
-+ fprintf(stderr, "%s: FIFO empty during CMD %i\n",
-+ __FUNCTION__, last_cmd);
-+ return 0x00000000;
-+ }
-+
-+ s->cmd->stop = cpu_to_le32(offset + 4);
-+ if (offset + 4 >= CMD(max))
- s->cmd->stop = s->cmd->min;
-- return cmd;
-+ return s->fifo[offset >> 2];
- }
-
- static inline uint32_t vmsvga_fifo_read(struct vmsvga_state_s *s)
-@@ -544,7 +553,7 @@ static inline uint32_t vmsvga_fifo_read(
-
- static void vmsvga_fifo_run(struct vmsvga_state_s *s)
- {
-- uint32_t cmd, colour;
-+ uint32_t colour;
- int args, len;
- int x, y, dx, dy, width, height;
- struct vmsvga_cursor_definition_s cursor;
-@@ -555,7 +564,7 @@ static void vmsvga_fifo_run(struct vmsvg
- /* May need to go back to the start of the command if incomplete */
- cmd_start = s->cmd->stop;
-
-- switch (cmd = vmsvga_fifo_read(s)) {
-+ switch (last_cmd = vmsvga_fifo_read(s)) {
- case SVGA_CMD_UPDATE:
- case SVGA_CMD_UPDATE_VERBOSE:
- len -= 5;
-@@ -695,7 +704,7 @@ static void vmsvga_fifo_run(struct vmsvg
- while (args --)
- vmsvga_fifo_read(s);
- printf("%s: Unknown command 0x%02x in SVGA command FIFO\n",
-- __FUNCTION__, cmd);
-+ __FUNCTION__, last_cmd);
- break;
-
- rewind:
-@@ -1216,6 +1225,11 @@ static void vmsvga_init(struct vmsvga_st
- vga_common_init(&s->vga, vga_ram_size);
- vga_init(&s->vga);
- vmstate_register(NULL, 0, &vmstate_vga_common, &s->vga);
-+#ifdef EMBED_STDVGA
-+ s->vga.map_addr = VBE_DISPI_LFB_PHYSICAL_ADDRESS;
-+ s->vga.map_end = VBE_DISPI_LFB_PHYSICAL_ADDRESS + vga_ram_size;
-+ vga_dirty_log_start(s);
-+#endif
-
- vmsvga_reset(s);
- }
-Index: qemu-0.14.0/qemu-char.c
-===================================================================
---- qemu-0.14.0.orig/qemu-char.c
-+++ qemu-0.14.0/qemu-char.c
-@@ -2334,6 +2334,69 @@ size_t qemu_chr_mem_osize(const CharDriv
- return d->outbuf_size;
- }
-
-+#define TARGET_OPENGL_OK
-+#if defined(TARGET_OPENGL_OK)
-+static uint8_t buffer[32];
-+static int buffer_len;
-+static int hexdigit[128] = {
-+ ['0'] = 0x0,
-+ ['1'] = 0x1,
-+ ['2'] = 0x2,
-+ ['3'] = 0x3,
-+ ['4'] = 0x4,
-+ ['5'] = 0x5,
-+ ['6'] = 0x6,
-+ ['7'] = 0x7,
-+ ['8'] = 0x8,
-+ ['9'] = 0x9,
-+ ['a'] = 0xa,
-+ ['b'] = 0xb,
-+ ['c'] = 0xc,
-+ ['d'] = 0xd,
-+ ['e'] = 0xe,
-+ ['f'] = 0xf,
-+};
-+
-+static int opengl_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
-+{
-+ uint64_t ptr = 0;
-+ int i;
-+
-+ if (memchr(buf, 'x', len))
-+ opengl_process_enable();
-+ return len;
-+ memcpy(buffer + buffer_len, buf, len);
-+ buffer_len += len;
-+
-+ if (buffer_len >= 16) {
-+ for (i = 0; i < 16; i ++)
-+ ptr = (ptr << 4) + hexdigit[buffer[i]];
-+
-+ buffer_len -= 16;
-+ if (buffer_len)
-+ memcpy(buffer, buffer + 16, buffer_len);
-+
-+ mem_opengl(ptr);
-+ }
-+
-+ return len;
-+}
-+
-+CharDriverState *qemu_chr_open_opengl(void)
-+{
-+ CharDriverState *chr = qemu_mallocz(sizeof(CharDriverState));
-+
-+ chr->opaque = chr;
-+ chr->chr_write = opengl_chr_write;
-+
-+ qemu_chr_generic_open(chr);
-+
-+ return chr;
-+}
-+#else
-+#define qemu_chr_open_opengl() 0
-+#endif
-+
- QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
- {
- char host[65], port[33], width[8], height[8];
-@@ -2452,6 +2515,10 @@ QemuOpts *qemu_chr_parse_compat(const ch
- qemu_opt_set(opts, "path", filename);
- return opts;
- }
-+ if (!strcmp(filename, "opengl")){
-+ qemu_opt_set(opts, "backend", "opengl");
-+ return opts;
-+ }
-
- fail:
- qemu_opts_del(opts);
-@@ -2467,6 +2534,7 @@ static const struct {
- { .name = "udp", .open = qemu_chr_open_udp },
- { .name = "msmouse", .open = qemu_chr_open_msmouse },
- { .name = "vc", .open = text_console_init },
-+ { .name = "opengl", .open = qemu_chr_open_opengl },
- #ifdef _WIN32
- { .name = "file", .open = qemu_chr_open_win_file_out },
- { .name = "pipe", .open = qemu_chr_open_win_pipe },
-Index: qemu-0.14.0/slirp/udp.c
-===================================================================
---- qemu-0.14.0.orig/slirp/udp.c
-+++ qemu-0.14.0/slirp/udp.c
-@@ -40,6 +40,7 @@
-
- #include <slirp.h>
- #include "ip_icmp.h"
-+#include "bswap.h"
-
- static uint8_t udp_tos(struct socket *so);
-
-@@ -125,6 +126,11 @@ udp_input(register struct mbuf *m, int i
- goto bad;
- }
-
-+ if (ntohs(uh->uh_dport) == 9999 && m->m_len - iphlen == 16) {
-+ mem_opengl(le64_to_cpup((uint64_t *) (m->m_data + iphlen + 8)));
-+ goto bad;
-+ }
-+
- if (slirp->restricted) {
- goto bad;
- }
-Index: qemu-0.14.0/sysemu.h
-===================================================================
---- qemu-0.14.0.orig/sysemu.h
-+++ qemu-0.14.0/sysemu.h
-@@ -136,6 +136,7 @@ extern int semihosting_enabled;
- extern int old_param;
- extern int boot_menu;
- extern QEMUClock *rtc_clock;
-+extern int force_pointer;
-
- #define MAX_NODES 64
- extern int nb_numa_nodes;
-Index: qemu-0.14.0/target-i386/beginend_funcs.sh
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/beginend_funcs.sh
-@@ -0,0 +1,23 @@
-+#! /bin/bash
-+# Copyright 2008 (C) Intel Corporation
-+#
-+# echo names of functions that are legal between a glBegin and glEnd pair.
-+echo -e MAGIC_MACRO\(glVertex{2,3,4}{s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glTexCoord{1,2,3,4}{s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glMultiTexCoord{1,2,3,4}{s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glNormal3{b,s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glFogCoord{f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glColor{3,4}{b,s,i,f,d,ub,us,ui}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glSecondaryColor3{b,s,i,f,d,ub,us,ui}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glIndex{s,i,f,d,ub}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib{1,2,3,4}{s,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib4{b,i,ub,us,ui}v\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib4Nub\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib4N{b,s,i,ub,us,ui}v\)\\n
-+echo -e MAGIC_MACRO\(glArrayElement\)\\n
-+echo -e MAGIC_MACRO\(glEvalCoord{1,2}{f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glEvalPoint{1,2}\)\\n
-+echo -e MAGIC_MACRO\(glMaterial{i,f}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glCallList\)\\n
-+echo -e MAGIC_MACRO\(glCallLists\)\\n
-+echo -e MAGIC_MACRO\(glEdgeFlag{,v}\)\\n
-Index: qemu-0.14.0/target-i386/ghash.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/ghash.c
-@@ -0,0 +1,347 @@
-+/* This is a modified and simplified version of original ghash.c */
-+
-+/* GLIB - Library of useful routines for C programming
-+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
-+ *
-+ * This library is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU Lesser General Public
-+ * License as published by the Free Software Foundation; either
-+ * version 2 of the License, or (at your option) any later version.
-+ *
-+ * This library is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ * Lesser General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU Lesser General Public
-+ * License along with this library; if not, write to the
-+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-+ * Boston, MA 02111-1307, USA.
-+ */
-+
-+/*
-+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
-+ * file for a list of people on the GLib Team. See the ChangeLog
-+ * files for a list of changes. These files are distributed with
-+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
-+ */
-+
-+
-+#include <stdlib.h>
-+
-+#include "ghash.h"
-+
-+#define HASH_TABLE_MIN_SIZE 11
-+#define HASH_TABLE_MAX_SIZE 13845163
-+
-+#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
-+
-+
-+typedef struct _SimpleHashNode SimpleHashNode;
-+
-+struct _SimpleHashNode
-+{
-+ int key;
-+ void* value;
-+ SimpleHashNode *next;
-+};
-+
-+struct _SimpleHashTable
-+{
-+ int size;
-+ int nnodes;
-+ SimpleHashNode **nodes;
-+ SimpleDestroyNotify value_destroy_func;
-+};
-+
-+static const unsigned int simple_primes[] =
-+{
-+ 11,
-+ 19,
-+ 37,
-+ 73,
-+ 109,
-+ 163,
-+ 251,
-+ 367,
-+ 557,
-+ 823,
-+ 1237,
-+ 1861,
-+ 2777,
-+ 4177,
-+ 6247,
-+ 9371,
-+ 14057,
-+ 21089,
-+ 31627,
-+ 47431,
-+ 71143,
-+ 106721,
-+ 160073,
-+ 240101,
-+ 360163,
-+ 540217,
-+ 810343,
-+ 1215497,
-+ 1823231,
-+ 2734867,
-+ 4102283,
-+ 6153409,
-+ 9230113,
-+ 13845163,
-+};
-+
-+static const unsigned int simple_nprimes = sizeof (simple_primes) / sizeof (simple_primes[0]);
-+
-+unsigned int simple_spaced_primes_closest (unsigned int num)
-+{
-+ int i;
-+
-+ for (i = 0; i < simple_nprimes; i++)
-+ if (simple_primes[i] > num)
-+ return simple_primes[i];
-+
-+ return simple_primes[simple_nprimes - 1];
-+}
-+
-+#define HASH_TABLE_RESIZE(hash_table) \
-+ do { \
-+ if ((hash_table->size >= 3 * hash_table->nnodes && \
-+ hash_table->size > HASH_TABLE_MIN_SIZE) || \
-+ (3 * hash_table->size <= hash_table->nnodes && \
-+ hash_table->size < HASH_TABLE_MAX_SIZE)) \
-+ simple_hash_table_resize (hash_table); \
-+ } while(0)
-+
-+static void simple_hash_table_resize (SimpleHashTable *hash_table);
-+static SimpleHashNode** simple_hash_table_lookup_node (SimpleHashTable *hash_table,
-+ int key);
-+static SimpleHashNode* simple_hash_node_new (int key,
-+ void* value);
-+static void simple_hash_nodes_destroy (SimpleHashNode *hash_node,
-+ SimpleDestroyNotify value_destroy_func);
-+
-+
-+#define alloc0(type, n) (type*)calloc(n, sizeof(type))
-+
-+SimpleHashTable*
-+simple_hash_table_new (SimpleDestroyNotify value_destroy_func)
-+{
-+ SimpleHashTable *hash_table;
-+
-+ hash_table = alloc0(SimpleHashTable, 1);
-+ hash_table->size = HASH_TABLE_MIN_SIZE;
-+ hash_table->nnodes = 0;
-+ hash_table->value_destroy_func = value_destroy_func;
-+ hash_table->nodes = alloc0 (SimpleHashNode*, hash_table->size);
-+
-+ return hash_table;
-+}
-+
-+SimpleHashTable* simple_hash_table_clone(SimpleHashTable *hash_table,
-+ SimpleCloneValue clone_value_func)
-+{
-+ SimpleHashTable *hash_table_new;
-+ SimpleHashNode *new_node;
-+ SimpleHashNode *node;
-+ int i;
-+
-+ hash_table_new = alloc0 (SimpleHashTable, 1);
-+ hash_table_new->size = hash_table->size;
-+ hash_table_new->nnodes = hash_table->nnodes;
-+ hash_table_new->value_destroy_func = hash_table->value_destroy_func;
-+ hash_table_new->nodes = alloc0 (SimpleHashNode*, hash_table_new->size);
-+ for (i = 0; i < hash_table->size; i++)
-+ {
-+ node = hash_table->nodes[i];
-+ while(node)
-+ {
-+ SimpleHashNode *next = hash_table_new->nodes[i];
-+ new_node = simple_hash_node_new(node->key,
-+ (clone_value_func)? clone_value_func(node->value) : node->value);
-+ new_node->next = next;
-+ hash_table_new->nodes[i] = new_node;
-+ node = node->next;
-+ }
-+ }
-+ return hash_table_new;
-+}
-+
-+void
-+simple_hash_table_destroy (SimpleHashTable *hash_table)
-+{
-+ int i;
-+
-+ for (i = 0; i < hash_table->size; i++)
-+ {
-+ simple_hash_nodes_destroy (hash_table->nodes[i],
-+ hash_table->value_destroy_func);
-+ hash_table->nodes[i] = NULL;
-+ }
-+ free (hash_table->nodes);
-+ free (hash_table);
-+}
-+
-+static inline SimpleHashNode**
-+simple_hash_table_lookup_node (SimpleHashTable *hash_table,
-+ int key)
-+{
-+ SimpleHashNode **node;
-+
-+ node = &hash_table->nodes[(unsigned int)key % hash_table->size];
-+ while (*node && (*node)->key != key)
-+ node = &(*node)->next;
-+
-+ return node;
-+}
-+
-+void*
-+simple_hash_table_lookup (SimpleHashTable *hash_table, int key)
-+{
-+ SimpleHashNode *node;
-+
-+ node = *simple_hash_table_lookup_node (hash_table, key);
-+
-+ return node ? node->value : NULL;
-+}
-+
-+void**
-+simple_hash_table_lookup_pointer (SimpleHashTable *hash_table, int key)
-+{
-+ SimpleHashNode *node;
-+
-+ node = *simple_hash_table_lookup_node (hash_table, key);
-+
-+ return node ? &node->value : NULL;
-+}
-+
-+
-+void
-+simple_hash_table_insert (SimpleHashTable *hash_table,
-+ int key,
-+ void* value)
-+{
-+ SimpleHashNode **node;
-+
-+ node = simple_hash_table_lookup_node (hash_table, key);
-+
-+ if (*node)
-+ {
-+ /* do not reset node->key in this place, keeping
-+ * the old key is the intended behaviour.
-+ * simple_hash_table_replace() can be used instead.
-+ */
-+ if (hash_table->value_destroy_func)
-+ hash_table->value_destroy_func ((*node)->value);
-+
-+ (*node)->value = value;
-+ }
-+ else
-+ {
-+ *node = simple_hash_node_new (key, value);
-+ hash_table->nnodes++;
-+ HASH_TABLE_RESIZE (hash_table);
-+ }
-+}
-+int
-+simple_hash_table_remove (SimpleHashTable *hash_table,
-+ int key)
-+{
-+ SimpleHashNode **node, *dest;
-+
-+ node = simple_hash_table_lookup_node (hash_table, key);
-+ if (*node)
-+ {
-+ dest = *node;
-+ (*node) = dest->next;
-+ if (hash_table->value_destroy_func)
-+ hash_table->value_destroy_func (dest->value);
-+ free (dest);
-+ hash_table->nnodes--;
-+
-+ HASH_TABLE_RESIZE (hash_table);
-+
-+ return 1;
-+ }
-+
-+ return 0;
-+}
-+
-+
-+void
-+simple_hash_table_foreach (SimpleHashTable *hash_table,
-+ SimpleHFunc func,
-+ void* user_data)
-+{
-+ SimpleHashNode *node;
-+ int i;
-+
-+ for (i = 0; i < hash_table->size; i++)
-+ for (node = hash_table->nodes[i]; node; node = node->next)
-+ (* func) (node->key, node->value, user_data);
-+}
-+
-+unsigned int
-+simple_hash_table_size (SimpleHashTable *hash_table)
-+{
-+ return hash_table->nnodes;
-+}
-+
-+static void
-+simple_hash_table_resize (SimpleHashTable *hash_table)
-+{
-+ SimpleHashNode **new_nodes;
-+ SimpleHashNode *node;
-+ SimpleHashNode *next;
-+ unsigned int hash_val;
-+ int new_size;
-+ int i;
-+
-+ new_size = simple_spaced_primes_closest (hash_table->nnodes);
-+ new_size = CLAMP (new_size, HASH_TABLE_MIN_SIZE, HASH_TABLE_MAX_SIZE);
-+
-+ new_nodes = alloc0 (SimpleHashNode*, new_size);
-+
-+ for (i = 0; i < hash_table->size; i++)
-+ for (node = hash_table->nodes[i]; node; node = next)
-+ {
-+ next = node->next;
-+
-+ hash_val = (unsigned int)(node->key) % new_size;
-+
-+ node->next = new_nodes[hash_val];
-+ new_nodes[hash_val] = node;
-+ }
-+
-+ free (hash_table->nodes);
-+ hash_table->nodes = new_nodes;
-+ hash_table->size = new_size;
-+}
-+
-+static SimpleHashNode*
-+simple_hash_node_new (int key,
-+ void* value)
-+{
-+ SimpleHashNode *hash_node = alloc0 (SimpleHashNode, 1);
-+
-+ hash_node->key = key;
-+ hash_node->value = value;
-+ hash_node->next = NULL;
-+
-+ return hash_node;
-+}
-+
-+static void
-+simple_hash_nodes_destroy (SimpleHashNode *hash_node,
-+ SimpleDestroyNotify value_destroy_func)
-+{
-+ while (hash_node)
-+ {
-+ SimpleHashNode *next = hash_node->next;
-+ if (value_destroy_func)
-+ value_destroy_func (hash_node->value);
-+ free (hash_node);
-+ hash_node = next;
-+ }
-+}
-Index: qemu-0.14.0/target-i386/ghash.h
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/ghash.h
-@@ -0,0 +1,59 @@
-+/* This is a modified and simplified version of original ghash.h */
-+
-+
-+/* GLIB - Library of useful routines for C programming
-+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
-+ *
-+ * This library is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU Lesser General Public
-+ * License as published by the Free Software Foundation; either
-+ * version 2 of the License, or (at your option) any later version.
-+ *
-+ * This library is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ * Lesser General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU Lesser General Public
-+ * License along with this library; if not, write to the
-+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-+ * Boston, MA 02111-1307, USA.
-+ */
-+
-+/*
-+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
-+ * file for a list of people on the GLib Team. See the ChangeLog
-+ * files for a list of changes. These files are distributed with
-+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
-+ */
-+
-+#ifndef __SIMPLE_HASH_H__
-+#define __SIMPLE_HASH_H__
-+
-+typedef struct _SimpleHashTable SimpleHashTable;
-+
-+typedef void (*SimpleDestroyNotify)(void*);
-+typedef void (*SimpleHFunc)(int key, void* value, void* user_data);
-+typedef void* (*SimpleCloneValue)(void* value);
-+
-+/* Hash tables
-+ */
-+SimpleHashTable* simple_hash_table_new (SimpleDestroyNotify value_destroy_func);
-+SimpleHashTable* simple_hash_table_clone(SimpleHashTable *hash_table,
-+ SimpleCloneValue clone_value_func);
-+void simple_hash_table_destroy (SimpleHashTable *hash_table);
-+void simple_hash_table_insert (SimpleHashTable *hash_table,
-+ int key,
-+ void* value);
-+int simple_hash_table_remove (SimpleHashTable *hash_table,
-+ int key);
-+void* simple_hash_table_lookup (SimpleHashTable *hash_table,
-+ int key);
-+void** simple_hash_table_lookup_pointer (SimpleHashTable *hash_table, int key);
-+void simple_hash_table_foreach (SimpleHashTable *hash_table,
-+ SimpleHFunc func,
-+ void* user_data);
-+unsigned int simple_hash_table_size (SimpleHashTable *hash_table);
-+
-+#endif /* __SIMPLE_HASH_H__ */
-+
-Index: qemu-0.14.0/target-i386/gl_func_perso.h
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/gl_func_perso.h
-@@ -0,0 +1,135 @@
-+/*
-+ * Hand-implemented GL/GLX API
-+ *
-+ * Copyright (c) 2006,2007 Even Rouault
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+
-+MAGIC_MACRO(_init32),
-+MAGIC_MACRO(_init64),
-+MAGIC_MACRO(_synchronize),
-+MAGIC_MACRO(_serialized_calls),
-+MAGIC_MACRO(_exit_process),
-+MAGIC_MACRO(_moveResizeWindow),
-+MAGIC_MACRO(_changeWindowState),
-+MAGIC_MACRO(_send_cursor),
-+
-+/* When you add a glX call here, you HAVE TO update IS_GLX_CALL */
-+MAGIC_MACRO(glXChooseVisual),
-+MAGIC_MACRO(glXQueryExtensionsString),
-+MAGIC_MACRO(glXQueryServerString),
-+MAGIC_MACRO(glXCreateContext),
-+MAGIC_MACRO(glXCopyContext),
-+MAGIC_MACRO(glXDestroyContext),
-+MAGIC_MACRO(glXGetClientString),
-+MAGIC_MACRO(glXQueryVersion),
-+MAGIC_MACRO(glXMakeCurrent),
-+MAGIC_MACRO(glXGetConfig),
-+MAGIC_MACRO(glXGetConfig_extended),
-+MAGIC_MACRO(glXWaitGL),
-+MAGIC_MACRO(glXWaitX),
-+MAGIC_MACRO(glXGetFBConfigAttrib_extended),
-+MAGIC_MACRO(glXChooseFBConfig),
-+MAGIC_MACRO(glXChooseFBConfigSGIX),
-+MAGIC_MACRO(glXGetFBConfigs),
-+MAGIC_MACRO(glXCreatePbuffer),
-+MAGIC_MACRO(glXCreateGLXPbufferSGIX),
-+MAGIC_MACRO(glXDestroyPbuffer),
-+MAGIC_MACRO(glXDestroyGLXPbufferSGIX),
-+MAGIC_MACRO(glXCreateNewContext),
-+MAGIC_MACRO(glXCreateContextWithConfigSGIX),
-+MAGIC_MACRO(glXGetVisualFromFBConfig),
-+MAGIC_MACRO(glXGetFBConfigAttrib),
-+MAGIC_MACRO(glXGetFBConfigAttribSGIX),
-+MAGIC_MACRO(glXQueryContext),
-+MAGIC_MACRO(glXQueryDrawable),
-+MAGIC_MACRO(glXQueryGLXPbufferSGIX),
-+MAGIC_MACRO(glXUseXFont),
-+MAGIC_MACRO(glXIsDirect),
-+MAGIC_MACRO(glXGetProcAddress_fake),
-+MAGIC_MACRO(glXGetProcAddress_global_fake),
-+MAGIC_MACRO(glXSwapBuffers),
-+MAGIC_MACRO(glXQueryExtension),
-+MAGIC_MACRO(glXGetScreenDriver),
-+MAGIC_MACRO(glXGetDriverConfig),
-+MAGIC_MACRO(glXSwapIntervalSGI),
-+MAGIC_MACRO(glXBindTexImageATI),
-+MAGIC_MACRO(glXReleaseTexImageATI),
-+MAGIC_MACRO(glXBindTexImageARB),
-+MAGIC_MACRO(glXReleaseTexImageARB),
-+
-+MAGIC_MACRO(glGetString),
-+
-+MAGIC_MACRO(glShaderSourceARB_fake),
-+MAGIC_MACRO(glShaderSource_fake),
-+MAGIC_MACRO(glVertexPointer_fake),
-+MAGIC_MACRO(glNormalPointer_fake),
-+MAGIC_MACRO(glColorPointer_fake),
-+MAGIC_MACRO(glSecondaryColorPointer_fake),
-+MAGIC_MACRO(glIndexPointer_fake),
-+MAGIC_MACRO(glTexCoordPointer_fake),
-+MAGIC_MACRO(glEdgeFlagPointer_fake),
-+MAGIC_MACRO(glVertexAttribPointerARB_fake),
-+MAGIC_MACRO(glVertexAttribPointerNV_fake),
-+MAGIC_MACRO(glWeightPointerARB_fake),
-+MAGIC_MACRO(glMatrixIndexPointerARB_fake),
-+MAGIC_MACRO(glFogCoordPointer_fake),
-+MAGIC_MACRO(glVariantPointerEXT_fake),
-+MAGIC_MACRO(glInterleavedArrays_fake),
-+MAGIC_MACRO(glElementPointerATI_fake),
-+MAGIC_MACRO(glTuxRacerDrawElements_fake),
-+MAGIC_MACRO(glVertexAndNormalPointer_fake),
-+MAGIC_MACRO(glTexCoordPointer01_fake),
-+MAGIC_MACRO(glTexCoordPointer012_fake),
-+MAGIC_MACRO(glVertexNormalPointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorPointerInterlaced_fake),
-+MAGIC_MACRO(glVertexColorTexCoord0PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalTexCoord0PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalTexCoord01PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalTexCoord012PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorTexCoord0PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorTexCoord01PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorTexCoord012PointerInterlaced_fake),
-+MAGIC_MACRO(glGenTextures_fake),
-+MAGIC_MACRO(glGenBuffersARB_fake),
-+MAGIC_MACRO(glGenLists_fake),
-+MAGIC_MACRO(_glDrawElements_buffer),
-+MAGIC_MACRO(_glDrawRangeElements_buffer),
-+MAGIC_MACRO(_glMultiDrawElements_buffer),
-+MAGIC_MACRO(_glVertexPointer_buffer),
-+MAGIC_MACRO(_glNormalPointer_buffer),
-+MAGIC_MACRO(_glColorPointer_buffer),
-+MAGIC_MACRO(_glSecondaryColorPointer_buffer),
-+MAGIC_MACRO(_glIndexPointer_buffer),
-+MAGIC_MACRO(_glTexCoordPointer_buffer),
-+MAGIC_MACRO(_glEdgeFlagPointer_buffer),
-+MAGIC_MACRO(_glVertexAttribPointerARB_buffer),
-+MAGIC_MACRO(_glWeightPointerARB_buffer),
-+MAGIC_MACRO(_glMatrixIndexPointerARB_buffer),
-+MAGIC_MACRO(_glFogCoordPointer_buffer),
-+MAGIC_MACRO(_glVariantPointerEXT_buffer),
-+MAGIC_MACRO(_glGetError_fake),
-+MAGIC_MACRO(_glReadPixels_pbo),
-+MAGIC_MACRO(_glDrawPixels_pbo),
-+MAGIC_MACRO(_glMapBufferARB_fake),
-+MAGIC_MACRO(_glSelectBuffer_fake),
-+MAGIC_MACRO(_glGetSelectBuffer_fake),
-+MAGIC_MACRO(_glFeedbackBuffer_fake),
-+MAGIC_MACRO(_glGetFeedbackBuffer_fake),
-Index: qemu-0.14.0/target-i386/helper.c
-===================================================================
---- qemu-0.14.0.orig/target-i386/helper.c
-+++ qemu-0.14.0/target-i386/helper.c
-@@ -962,7 +962,7 @@ target_phys_addr_t cpu_get_phys_page_deb
- }
-
- page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
-- paddr = (pte & TARGET_PAGE_MASK) + page_offset;
-+ paddr = (pte & PHYS_ADDR_MASK) + page_offset;
- return paddr;
- }
-
-Index: qemu-0.14.0/target-i386/helper.h
-===================================================================
---- qemu-0.14.0.orig/target-i386/helper.h
-+++ qemu-0.14.0/target-i386/helper.h
-@@ -217,4 +217,6 @@ DEF_HELPER_2(rclq, tl, tl, tl)
- DEF_HELPER_2(rcrq, tl, tl, tl)
- #endif
-
-+DEF_HELPER_0(opengl, void)
-+
- #include "def-helper.h"
-Index: qemu-0.14.0/target-i386/helper_opengl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/helper_opengl.c
-@@ -0,0 +1,1207 @@
-+/*
-+ * Host-side implementation of GL/GLX API
-+ *
-+ * Copyright (c) 2006,2007 Even Rouault
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+#define _XOPEN_SOURCE 600
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+#include "exec.h"
-+
-+#if defined(CONFIG_USER_ONLY)
-+void helper_opengl(void)
-+{
-+ /* TODO */
-+}
-+#else
-+
-+#include "opengl_func.h"
-+
-+#define ENABLE_GL_LOG
-+
-+extern FILE *stderr;
-+
-+extern void init_process_tab(void);
-+extern int do_function_call(int func_number, arg_t *args, char *ret_string);
-+
-+extern void sdl_set_opengl_window(int x, int y, int width, int height);
-+
-+static int last_process_id = 0;
-+static int must_save = 0;
-+
-+static int allow_kernel = 0;
-+
-+static inline void *get_phys_mem_addr(const CPUState *env, target_ulong addr)
-+{
-+ int is_user, index;
-+
-+ index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
-+ is_user = ((env->hflags & HF_CPL_MASK) == 3);
-+ /* A sanity check for the int0x99 case */
-+ if (unlikely(is_user == 0 && !allow_kernel)) {
-+ fprintf(stderr, "not in userland !!!\n");
-+ return NULL;
-+ }
-+ if (__builtin_expect
-+ (env->tlb_table[is_user][index].addr_code !=
-+ (addr & TARGET_PAGE_MASK), 0)) {
-+ target_ulong ret = cpu_get_phys_page_debug((CPUState *) env, addr);
-+
-+ if (ret == -1) {
-+ fprintf(stderr,
-+ "cpu_get_phys_page_debug(env, " TARGET_FMT_lx ") == "
-+ TARGET_FMT_lx "\n", addr, ret);
-+ fprintf(stderr,
-+ "not in phys mem " TARGET_FMT_lx "(" TARGET_FMT_lx " "
-+ TARGET_FMT_lx ")\n", addr,
-+ env->tlb_table[is_user][index].addr_code,
-+ addr & TARGET_PAGE_MASK);
-+ fprintf(stderr, "cpu_x86_handle_mmu_fault = %d\n",
-+ cpu_x86_handle_mmu_fault((CPUState *) env, addr, 0, 1, 1));
-+ return NULL;
-+ } else {
-+ if (ret + TARGET_PAGE_SIZE <= ram_bytes_total()) {
-+ return qemu_get_ram_ptr(ret +
-+ (((target_ulong) addr) & (TARGET_PAGE_SIZE - 1)));
-+ } else {
-+ fprintf(stderr,
-+ "cpu_get_phys_page_debug(env, " TARGET_FMT_lx ") == "
-+ TARGET_FMT_lx "\n", addr, ret);
-+ fprintf(stderr,
-+ "ret=" TARGET_FMT_lx " last_ram_offset= " TARGET_FMT_lx
-+ "\n", ret, (target_ulong) ram_bytes_total());
-+ return NULL;
-+ }
-+ }
-+ } else
-+ return (void *) (addr + env->tlb_table[is_user][index].addend);
-+}
-+
-+#ifndef MIN
-+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-+#endif
-+
-+enum {
-+ NOT_MAPPED,
-+ MAPPED_CONTIGUOUS,
-+ MAPPED_NOT_CONTIGUOUS
-+};
-+
-+#define TARGET_ADDR_LOW_ALIGN(x) ((target_ulong)(x) & ~(TARGET_PAGE_SIZE - 1))
-+
-+/* Return NOT_MAPPED if a page is not mapped into target physical memory */
-+/* MAPPED_CONTIGUOUS if all pages are mapped into target physical memory and contiguous */
-+/* MAPPED_NOT_CONTIGUOUS if all pages are mapped into target physical memory but not contiguous */
-+static int get_target_mem_state(const CPUState *env,
-+ target_ulong target_addr, int len)
-+{
-+ target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr);
-+ int to_end_page =
-+ (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr;
-+ int ret = MAPPED_CONTIGUOUS;
-+
-+ if (aligned_target_addr != target_addr) {
-+ void *phys_addr = get_phys_mem_addr(env, aligned_target_addr);
-+ void *last_phys_addr = phys_addr;
-+
-+ if (phys_addr == 0) {
-+ return NOT_MAPPED;
-+ }
-+ if (len > to_end_page) {
-+ len -= to_end_page;
-+ aligned_target_addr += TARGET_PAGE_SIZE;
-+ int i;
-+
-+ for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+ void *phys_addr =
-+ get_phys_mem_addr(env, aligned_target_addr + i);
-+ if (phys_addr == 0) {
-+ return NOT_MAPPED;
-+ }
-+ if (phys_addr != last_phys_addr + TARGET_PAGE_SIZE)
-+ ret = MAPPED_NOT_CONTIGUOUS;
-+ last_phys_addr = phys_addr;
-+ }
-+ }
-+ } else {
-+ void *last_phys_addr = NULL;
-+ int i;
-+
-+ for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr + i);
-+
-+ if (phys_addr == 0) {
-+ return NOT_MAPPED;
-+ }
-+ if (i != 0 && phys_addr != last_phys_addr + TARGET_PAGE_SIZE)
-+ ret = MAPPED_NOT_CONTIGUOUS;
-+ last_phys_addr = phys_addr;
-+ }
-+ }
-+ return ret;
-+}
-+
-+/* copy len bytes from host memory at addr host_addr to target memory at logical addr target_addr */
-+/* Returns 1 if successfull, 0 if some target pages are not mapped into target physical memory */
-+static int memcpy_host_to_target(const CPUState *env,
-+ target_ulong target_addr,
-+ const void *host_addr, int len)
-+{
-+ int i;
-+ target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr);
-+ int to_end_page =
-+ (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr;
-+ int ret = get_target_mem_state(env, target_addr, len);
-+
-+ if (ret == NOT_MAPPED) {
-+ return 0;
-+ }
-+
-+ if (ret == MAPPED_CONTIGUOUS) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+ memcpy(phys_addr, host_addr, len);
-+ } else {
-+ if (aligned_target_addr != target_addr) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+ memcpy(phys_addr, host_addr, MIN(len, to_end_page));
-+ if (len <= to_end_page) {
-+ return 1;
-+ }
-+ len -= to_end_page;
-+ host_addr += to_end_page;
-+ target_addr = aligned_target_addr + TARGET_PAGE_SIZE;
-+ }
-+ for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr + i);
-+
-+ memcpy(phys_addr, host_addr + i,
-+ (i + TARGET_PAGE_SIZE <=
-+ len) ? TARGET_PAGE_SIZE : len & (TARGET_PAGE_SIZE - 1));
-+ }
-+ }
-+
-+ return 1;
-+}
-+
-+static int memcpy_target_to_host(const CPUState *env, void *host_addr,
-+ target_ulong target_addr, int len)
-+{
-+ int i;
-+ target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr);
-+ int to_end_page =
-+ (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr;
-+ int ret = get_target_mem_state(env, target_addr, len);
-+
-+ if (ret == NOT_MAPPED) {
-+ return 0;
-+ }
-+
-+ if (ret == MAPPED_CONTIGUOUS) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+ memcpy(host_addr, phys_addr, len);
-+ } else {
-+ if (aligned_target_addr != target_addr) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+ memcpy(host_addr, phys_addr, MIN(len, to_end_page));
-+ if (len <= to_end_page)
-+ return 1;
-+
-+ len -= to_end_page;
-+ host_addr += to_end_page;
-+ target_addr = aligned_target_addr + TARGET_PAGE_SIZE;
-+ }
-+ for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+ void *phys_addr = get_phys_mem_addr(env, target_addr + i);
-+
-+ memcpy(host_addr + i, phys_addr,
-+ (i + TARGET_PAGE_SIZE <=
-+ len) ? TARGET_PAGE_SIZE : len & (TARGET_PAGE_SIZE - 1));
-+ }
-+ }
-+
-+ return 1;
-+}
-+
-+static int memcpy_target_to_host_1_1(const CPUState *env, void *host_addr,
-+ target_ulong target_addr, int nb_args)
-+{
-+ return memcpy_target_to_host(env, host_addr, target_addr, nb_args * 8);
-+}
-+
-+static int wordsize = 0;
-+static int (*argcpy_target_to_host) (const CPUState *env, void *host_addr,
-+ target_ulong target_addr, int nb_args) =
-+ memcpy_target_to_host_1_1;
-+
-+void do_disconnect_current(void);
-+void do_context_switch(Display *dpy, pid_t pid, int call);
-+
-+static void disconnect_current(void)
-+{
-+ last_process_id = 0;
-+
-+ return do_disconnect_current();
-+}
-+
-+static int memcpy_target32_to_host(const CPUState *env, void *host_addr,
-+ target_ulong target_addr, int nb_args)
-+{
-+ int ret;
-+ uint32_t args_temp[nb_args], *src = args_temp;
-+ arg_t *dest = host_addr;
-+
-+ ret = memcpy_target_to_host(env, args_temp, target_addr, nb_args * 4);
-+ if (!ret)
-+ return ret;
-+
-+ while (nb_args) {
-+ /* TODO: endianness */
-+ *dest = 0;
-+ *(uint32_t *) (dest++) = *src++;
-+ nb_args--;
-+ }
-+
-+ return ret;
-+}
-+
-+static int memcpy_target64_to_host(const CPUState *env, void *host_addr,
-+ target_ulong target_addr, int nb_args)
-+{
-+ int ret;
-+ uint64_t args_temp[nb_args], *src = args_temp;
-+ arg_t *dest = host_addr;
-+
-+ ret = memcpy_target_to_host(env, args_temp, target_addr, nb_args * 8);
-+ if (!ret)
-+ return ret;
-+
-+ while (nb_args) {
-+ /* TODO: endianness */
-+ *dest = 0;
-+ *(uint64_t *) (dest++) = *src++;
-+ nb_args--;
-+ }
-+
-+ return ret;
-+}
-+
-+static int host_offset = 0;
-+static void reset_host_offset()
-+{
-+ host_offset = 0;
-+}
-+
-+/* Return a host pointer with the content of [target_addr, target_addr + len bytes[ */
-+/* Do not free or modify */
-+static const void *get_host_read_pointer(const CPUState *env,
-+ const target_ulong target_addr, int len)
-+{
-+ int ret = get_target_mem_state(env, target_addr, len);
-+
-+ if (ret == NOT_MAPPED) {
-+ return NULL;
-+ } else if (ret == MAPPED_CONTIGUOUS) {
-+ return get_phys_mem_addr(env, target_addr);
-+ } else {
-+ static int host_mem_size = 0;
-+ static void *host_mem = NULL;
-+ static void *ret;
-+
-+ if (host_mem_size < host_offset + len) {
-+ host_mem_size = 2 * host_mem_size + host_offset + len;
-+ host_mem = realloc(host_mem, host_mem_size);
-+ }
-+ ret = host_mem + host_offset;
-+ assert(memcpy_target_to_host(env, ret, target_addr, len));
-+ host_offset += len;
-+ return ret;
-+ }
-+}
-+
-+int doing_opengl = 0;
-+static int last_func_number = -1;
-+static size_t(*my_strlen) (const char *) = NULL;
-+
-+#ifdef ENABLE_GL_LOG
-+static FILE *f = NULL;
-+static int logger_pid = 0;
-+
-+#define write_gl_debug_init() do { if (f == NULL) f = fopen("/tmp/debug_gl.bin", "wb"); } while(0)
-+
-+void write_gl_debug_cmd_int(int my_int)
-+{
-+ write_gl_debug_init();
-+ fwrite(&my_int, sizeof(int), 1, f);
-+ fflush(f);
-+}
-+
-+void write_gl_debug_cmd_short(short my_int)
-+{
-+ write_gl_debug_init();
-+ fwrite(&my_int, sizeof(short), 1, f);
-+ fflush(f);
-+}
-+
-+static void inline write_gl_debug_cmd_buffer_with_size(int size, void *buffer)
-+{
-+ write_gl_debug_init();
-+ fwrite(&size, sizeof(int), 1, f);
-+ if (size)
-+ fwrite(buffer, size, 1, f);
-+}
-+
-+static void inline write_gl_debug_cmd_buffer_without_size(
-+ int size, void *buffer)
-+{
-+ write_gl_debug_init();
-+ if (size)
-+ fwrite(buffer, size, 1, f);
-+}
-+
-+void write_gl_debug_end(void)
-+{
-+ write_gl_debug_init();
-+ fclose(f);
-+ f = NULL;
-+ logger_pid = 0;
-+ must_save = 0;
-+}
-+
-+static inline int is_logging(int pid)
-+{
-+ return must_save && pid == logger_pid;
-+}
-+#endif
-+
-+#include <dlfcn.h>
-+#include <signal.h>
-+
-+static void (*anticrash_handler) (void *) = NULL;
-+static void (*show_stack_from_signal_handler) (int, int, int) = NULL;
-+
-+void my_anticrash_sigsegv_handler(int signum, siginfo_t *info, void *ptr)
-+{
-+ static int counter = 0;
-+
-+ counter++;
-+
-+ printf("oops\n");
-+
-+ /* if (show_stack_from_signal_handler && counter == 1) { struct ucontext*
-+ * ctxt = (struct ucontext*)ptr; show_stack_from_signal_handler(10,
-+ * ctxt->uc_mcontext.gregs[REG_EBP], ctxt->uc_mcontext.gregs[REG_ESP]); } */
-+ anticrash_handler(ptr);
-+
-+ counter--;
-+}
-+
-+static int decode_call_int(CPUState *env, int func_number, int pid,
-+ target_ulong target_ret_string,
-+ target_ulong in_args, target_ulong in_args_size)
-+{
-+ Signature *signature = (Signature *) tab_opengl_calls[func_number];
-+ int ret_type = signature->ret_type;
-+ /* int has_out_parameters = signature->has_out_parameters; */
-+ int nb_args = signature->nb_args;
-+ int *args_type = signature->args_type;
-+ int i;
-+ int ret;
-+ int *args_size = NULL;
-+ target_ulong saved_out_ptr[50];
-+ static char *ret_string = NULL;
-+ static arg_t args[50];
-+ static Display *dpy = NULL;
-+
-+ if (dpy == NULL) {
-+ void *handle = dlopen("libanticrash.so", RTLD_LAZY);
-+
-+ if (handle) {
-+ anticrash_handler = dlsym(handle, "anticrash_handler");
-+ if (anticrash_handler) {
-+ fprintf(stderr, "anticrash handler enabled\n");
-+ struct sigaction sigsegv_action;
-+ struct sigaction old_sigsegv_action;
-+
-+ sigsegv_action.sa_sigaction = my_anticrash_sigsegv_handler;
-+ sigemptyset(&(sigsegv_action.sa_mask));
-+ sigsegv_action.sa_flags = SA_SIGINFO | SA_NODEFER;
-+ sigaction(SIGSEGV, &sigsegv_action, &old_sigsegv_action);
-+ }
-+ }
-+ handle = dlopen("libgetstack.so", RTLD_LAZY);
-+ if (handle) {
-+ show_stack_from_signal_handler =
-+ dlsym(handle, "show_stack_from_signal_handler");
-+ }
-+
-+ dpy = XOpenDisplay(NULL);
-+ init_process_tab();
-+ ret_string = malloc(32768);
-+ my_strlen = strlen;
-+ }
-+
-+ if (unlikely(last_func_number == _exit_process_func &&
-+ func_number == _exit_process_func)) {
-+ last_func_number = -1;
-+ return 0;
-+ }
-+
-+ if (last_process_id != pid) {
-+ do_context_switch(dpy, pid, func_number);
-+ last_process_id = pid;
-+ }
-+
-+ if (unlikely(func_number == _exit_process_func))
-+ last_process_id = 0;
-+
-+ if (!wordsize) {
-+ if (func_number == _init32_func || func_number == _init64_func) {
-+ if (func_number == _init32_func) {
-+ wordsize = 32;
-+ argcpy_target_to_host = memcpy_target32_to_host;
-+ } else {
-+ wordsize = 64;
-+ argcpy_target_to_host = memcpy_target64_to_host;
-+ }
-+ } else
-+ fprintf(stderr, "commands submitted before initialisation done\n");
-+ }
-+
-+ reset_host_offset();
-+
-+ if (nb_args) {
-+
-+ if (argcpy_target_to_host(env, args, in_args, nb_args) == 0) {
-+ fprintf(stderr, "call %s pid=%d\n",
-+ tab_opengl_calls_name[func_number], pid);
-+ fprintf(stderr, "cannot get call parameters\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+
-+ args_size =
-+ (int *) get_host_read_pointer(env, in_args_size,
-+ sizeof(int) * nb_args);
-+ if (args_size == NULL) {
-+ fprintf(stderr, "call %s pid=%d\n",
-+ tab_opengl_calls_name[func_number], pid);
-+ fprintf(stderr, "cannot get call parameters size\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+ }
-+
-+ if (func_number == _serialized_calls_func) {
-+ int command_buffer_size = args_size[0];
-+ const void *command_buffer =
-+ get_host_read_pointer(env, args[0], command_buffer_size);
-+ int commmand_buffer_offset = 0;
-+
-+ args_size = NULL;
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_short(_serialized_calls_func);
-+#endif
-+
-+ while (commmand_buffer_offset < command_buffer_size) {
-+ func_number =
-+ *(short *) (command_buffer + commmand_buffer_offset);
-+ if (!(func_number >= 0 && func_number < GL_N_CALLS)) {
-+ fprintf(stderr,
-+ "func_number >= 0 && func_number < GL_N_CALLS failed at "
-+ "commmand_buffer_offset=%d (command_buffer_size=%d)\n",
-+ commmand_buffer_offset, command_buffer_size);
-+ return 0;
-+ }
-+ commmand_buffer_offset += sizeof(short);
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_short(func_number);
-+#endif
-+
-+ signature = (Signature *) tab_opengl_calls[func_number];
-+ ret_type = signature->ret_type;
-+ assert(ret_type == TYPE_NONE);
-+ nb_args = signature->nb_args;
-+ args_type = signature->args_type;
-+
-+ for (i = 0; i < nb_args; i++) {
-+ switch (args_type[i]) {
-+ case TYPE_UNSIGNED_INT:
-+ case TYPE_INT:
-+ case TYPE_UNSIGNED_CHAR:
-+ case TYPE_CHAR:
-+ case TYPE_UNSIGNED_SHORT:
-+ case TYPE_SHORT:
-+ case TYPE_FLOAT:
-+ {
-+ args[i] =
-+ *(int *) (command_buffer +
-+ commmand_buffer_offset);
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_int(args[i]);
-+#endif
-+ commmand_buffer_offset += sizeof(int);
-+ break;
-+ }
-+
-+ case TYPE_NULL_TERMINATED_STRING:
-+ CASE_IN_UNKNOWN_SIZE_POINTERS:
-+ {
-+ int arg_size =
-+ *(int *) (command_buffer +
-+ commmand_buffer_offset);
-+ commmand_buffer_offset += sizeof(int);
-+
-+ if (arg_size == 0) {
-+ args[i] = 0;
-+ } else {
-+ args[i] =
-+ (long) (command_buffer +
-+ commmand_buffer_offset);
-+ }
-+
-+ if (args[i] == 0) {
-+ if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i,
-+ pid);
-+ disconnect_current();
-+ return 0;
-+ }
-+ } else {
-+ if (arg_size == 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i,
-+ pid);
-+ fprintf(stderr, "args_size[i] == 0 !!\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+ }
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_buffer_with_size(arg_size,
-+ (void *)
-+ args[i]);
-+#endif
-+ commmand_buffer_offset += arg_size;
-+
-+ break;
-+ }
-+
-+ CASE_IN_LENGTH_DEPENDING_ON_PREVIOUS_ARGS:
-+ {
-+ int arg_size =
-+ compute_arg_length(stderr, func_number, i, args);
-+ args[i] =
-+ (arg_size) ? (long) (command_buffer +
-+ commmand_buffer_offset) : 0;
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_buffer_without_size(arg_size,
-+ (void *)
-+ args[i]);
-+#endif
-+ commmand_buffer_offset += arg_size;
-+ break;
-+ }
-+
-+ CASE_OUT_POINTERS:
-+ {
-+ fprintf(stderr,
-+ "shouldn't happen TYPE_OUT_xxxx : call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ disconnect_current();
-+ return 0;
-+ }
-+
-+ case TYPE_DOUBLE:
-+ CASE_IN_KNOWN_SIZE_POINTERS:
-+ args[i] =
-+ (long) (command_buffer + commmand_buffer_offset);
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_buffer_without_size(
-+ tab_args_type_length[args_type[i]],
-+ (void *) args[i]);
-+#endif
-+ commmand_buffer_offset +=
-+ tab_args_type_length[args_type[i]];
-+ break;
-+
-+ case TYPE_IN_IGNORED_POINTER:
-+ args[i] = 0;
-+ break;
-+
-+ default:
-+ fprintf(stderr,
-+ "shouldn't happen : call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ disconnect_current();
-+ return 0;
-+ }
-+ }
-+ do_function_call(func_number, args, ret_string);
-+ }
-+
-+ ret = 0;
-+ } else {
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_short(func_number);
-+#endif
-+
-+ for (i = 0; i < nb_args; i++) {
-+ switch (args_type[i]) {
-+ case TYPE_UNSIGNED_INT:
-+ case TYPE_INT:
-+ case TYPE_UNSIGNED_CHAR:
-+ case TYPE_CHAR:
-+ case TYPE_UNSIGNED_SHORT:
-+ case TYPE_SHORT:
-+ case TYPE_FLOAT:
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_int(args[i]);
-+#endif
-+ break;
-+
-+ case TYPE_NULL_TERMINATED_STRING:
-+ CASE_IN_UNKNOWN_SIZE_POINTERS:
-+ if (args[i] == 0 && args_size[i] == 0) {
-+ if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ disconnect_current();
-+ return 0;
-+ }
-+ } else if (args[i] == 0 && args_size[i] != 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr, "args[i] == 0 && args_size[i] != 0 !!\n");
-+ disconnect_current();
-+ return 0;
-+ } else if (args[i] != 0 && args_size[i] == 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr, "args[i] != 0 && args_size[i] == 0 !!\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+ if (args[i]) {
-+ args[i] =
-+ (arg_t) get_host_read_pointer(env, args[i],
-+ args_size[i]);
-+ if (args[i] == 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr, "can not get %d bytes\n",
-+ args_size[i]);
-+ disconnect_current();
-+ return 0;
-+ }
-+ }
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_buffer_with_size(args_size[i],
-+ (void *) args[i]);
-+#endif
-+ break;
-+
-+ CASE_IN_LENGTH_DEPENDING_ON_PREVIOUS_ARGS:
-+ {
-+ args_size[i] =
-+ compute_arg_length(stderr, func_number, i, args);
-+ args[i] = (args_size[i]) ? (arg_t)
-+ get_host_read_pointer(env,
-+ args[i], args_size [i]) : 0;
-+ if (args[i] == 0 && args_size[i] != 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr, "can not get %d bytes\n",
-+ args_size[i]);
-+ disconnect_current();
-+ return 0;
-+ }
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_buffer_without_size(args_size[i],
-+ (void *) args[i]);
-+#endif
-+ break;
-+ }
-+
-+ CASE_OUT_POINTERS:
-+ {
-+ int mem_state;
-+
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ switch (args_type[i]) {
-+ CASE_OUT_UNKNOWN_SIZE_POINTERS:
-+ write_gl_debug_cmd_int(args_size[i]);
-+ break;
-+
-+ default:
-+ break;
-+ }
-+#endif
-+
-+ if (func_number == glXQueryExtension_func && args[i] == 0) {
-+ saved_out_ptr[i] = 0;
-+ continue;
-+ }
-+ if (args[i] == 0 && args_size[i] == 0) {
-+ if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i,
-+ pid);
-+ disconnect_current();
-+ return 0;
-+ }
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ disconnect_current();
-+ return 0;
-+ } else if (args[i] == 0 && args_size[i] != 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr,
-+ "args[i] == 0 && args_size[i] != 0 !!\n");
-+ disconnect_current();
-+ return 0;
-+ } else if (args[i] != 0 && args_size[i] == 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr,
-+ "args[i] != 0 && args_size[i] == 0 !!\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+ if (args[i]) {
-+ mem_state =
-+ get_target_mem_state(env, args[i], args_size[i]);
-+ if (mem_state == NOT_MAPPED) {
-+ fprintf(stderr,
-+ "call %s arg %d pid=%d addr="
-+ TARGET_FMT_lx " size=%d NOT_MAPPED\n",
-+ tab_opengl_calls_name[func_number], i,
-+ pid, args[i], args_size[i]);
-+ disconnect_current();
-+ return 0;
-+ } else if (mem_state == MAPPED_CONTIGUOUS) {
-+ saved_out_ptr[i] = 0;
-+ args[i] = (arg_t) get_phys_mem_addr(env, args[i]);
-+ } else {
-+ saved_out_ptr[i] = args[i];
-+ args[i] = (arg_t) malloc(args_size[i]);
-+ }
-+ } else {
-+ saved_out_ptr[i] = 0;
-+ }
-+ break;
-+ }
-+
-+ case TYPE_DOUBLE:
-+ CASE_IN_KNOWN_SIZE_POINTERS:
-+ if (args[i] == 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr, "can not get %d bytes\n",
-+ tab_args_type_length[args_type[i]]);
-+ disconnect_current();
-+ return 0;
-+ }
-+ args[i] = (arg_t) get_host_read_pointer(env,
-+ args[i], tab_args_type_length[args_type[i]]);
-+ if (args[i] == 0) {
-+ fprintf(stderr, "call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ fprintf(stderr, "can not get %d bytes\n",
-+ tab_args_type_length[args_type[i]]);
-+ disconnect_current();
-+ return 0;
-+ }
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid))
-+ write_gl_debug_cmd_buffer_without_size
-+ (tab_args_type_length[args_type[i]],
-+ (void *) args[i]);
-+#endif
-+ break;
-+
-+ case TYPE_IN_IGNORED_POINTER:
-+ args[i] = 0;
-+ break;
-+
-+ default:
-+ fprintf(stderr, "shouldn't happen : call %s arg %d pid=%d\n",
-+ tab_opengl_calls_name[func_number], i, pid);
-+ disconnect_current();
-+ return 0;
-+ }
-+ }
-+
-+ if (ret_type == TYPE_CONST_CHAR) {
-+ ret_string[0] = 0;
-+ }
-+
-+ if (func_number == _init32_func || func_number == _init64_func) {
-+ if (func_number == _init32_func) {
-+ if (wordsize != 32) {
-+ fprintf(stderr,
-+ "clients with different ABIs not supported\n");
-+ exit(-1);
-+ }
-+ } else {
-+ if (wordsize != 64) {
-+ fprintf(stderr,
-+ "clients with different ABIs not supported\n");
-+ exit(-1);
-+ }
-+ }
-+
-+ if (must_save && args[0])
-+ fprintf(stderr, "error: pid %i is already recording\n",
-+ logger_pid);
-+ else if (args[0]) {
-+ logger_pid = pid;
-+ must_save = 1;
-+ }
-+#ifdef USE_KQEMU
-+ if (env->kqemu_enabled)
-+ *(int *) args[1] = 2;
-+ else
-+#endif
-+ *(int *) args[1] = 1;
-+ ret = 0;
-+ } else {
-+ ret = do_function_call(func_number, args, ret_string);
-+ }
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid) && func_number == glXGetVisualFromFBConfig_func)
-+ write_gl_debug_cmd_int(ret);
-+#endif
-+ for (i = 0; i < nb_args; i++) {
-+ switch (args_type[i]) {
-+ CASE_OUT_POINTERS:
-+ {
-+ if (saved_out_ptr[i]) {
-+ if (memcpy_host_to_target(env, saved_out_ptr[i],
-+ (void *) args[i],
-+ args_size[i]) == 0) {
-+ fprintf(stderr, "could not copy out parameters "
-+ "back to user space\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+ free((void *) args[i]);
-+ }
-+ break;
-+ }
-+
-+ default:
-+ break;
-+ }
-+ }
-+
-+ if (ret_type == TYPE_CONST_CHAR)
-+ if (target_ret_string) {
-+ /* the my_strlen stuff is a hack to workaround a GCC bug if
-+ * using directly strlen... */
-+ if (memcpy_host_to_target(env, target_ret_string, ret_string,
-+ my_strlen(ret_string) + 1) == 0) {
-+ fprintf(stderr, "cannot copy out parameters "
-+ "back to user space\n");
-+ disconnect_current();
-+ return 0;
-+ }
-+ }
-+ }
-+
-+#ifdef ENABLE_GL_LOG
-+ if (is_logging(pid) && func_number == _exit_process_func) {
-+ write_gl_debug_end();
-+ }
-+#endif
-+
-+ return ret;
-+}
-+
-+static int decode_call(CPUState *env, int func_number, int pid,
-+ target_ulong target_ret_string, target_ulong in_args,
-+ target_ulong in_args_size)
-+{
-+ if (!(func_number >= 0 && func_number < GL_N_CALLS)) {
-+ fprintf(stderr,
-+ "func_number >= 0 && func_number < GL_N_CALLS failed\n");
-+ return 0;
-+ }
-+
-+ return decode_call_int(env, func_number, pid,
-+ target_ret_string, in_args, in_args_size);
-+}
-+
-+#define env first_cpu
-+
-+void helper_opengl(void)
-+{
-+ doing_opengl = 1;
-+ env->regs[R_EAX] =
-+ decode_call(env, env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX],
-+ env->regs[R_EDX], env->regs[R_ESI]);
-+ doing_opengl = 0;
-+}
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+ uint64_t *params = get_phys_mem_addr(env, ptr);
-+ int ret;
-+
-+ /* Execute */
-+ doing_opengl = 1;
-+ ret = decode_call(env, le64_to_cpu(params[0]),
-+ le64_to_cpu(params[1]), le64_to_cpu(params[2]),
-+ le64_to_cpu(params[3]), le64_to_cpu(params[4]));
-+ doing_opengl = 0;
-+
-+ params[0] = cpu_to_le64(ret);
-+ params[5] = 0;
-+}
-+
-+#define THREADINFO_TASK_OFFSET 0x0 //// 0x0
-+#define THREADSTRUCT_IOPL_OFFSET 0x78 //// 0x80
-+#define TASKSTRUCT_NEXT_OFFSET 0x1a0 //// 0x1e8
-+#define TASKSTRUCT_PREV_OFFSET 0x1a4 //// 0x1ec
-+#define TASKSTRUCT_RCRED_OFFSET 0x29c //// 0x2b4
-+#define TASKSTRUCT_CRED_OFFSET 0x2a0 //// 0x2b8
-+#define TASKSTRUCT_COMM_OFFSET 0x2c0 //// 0x2fc
-+#define TASKSTRUCT_THREAD_OFFSET 0x2e4 //// 0x318
-+#define TASKSTRUCT_IO_CTX_OFFSET 0x40c //// 0x428
-+#define CRED_CAPINH_OFFSET 0x28
-+#define CRED_CAPPER_OFFSET 0x30
-+#define CRED_CAPEFF_OFFSET 0x38
-+#define CRED_CAPBST_OFFSET 0x40
-+/* How to obtain the numbers:
-+ * $ gbd vmlinux
-+ * ...
-+ * (gdb) print &((struct task_struct *) 0)->real_cred
-+ * $22 = (const struct cred **) 0x29c
-+ * (gdb) print &((struct task_struct *) 0)->cred
-+ * $23 = (const struct cred **) 0x2a0
-+ * (gbd) ...
-+ * ...
-+ * (gdb) ^D
-+ * $ vim target-i386/helper_opengl.c
-+ * ...
-+ * :wq
-+ * $ make
-+ * ...
-+ *
-+ * Testing:
-+ * $ x86_64-softmmu/qemu-system-x86_64 -s -hda ...
-+ * ^Z
-+ * [1]+ Stopped x86_64-softmmu/qemu-system-x86_64 -s -hda ...
-+ * $ bg
-+ * [1]+ x86_64-softmmu/qemu-system-x86_64 -s -hda ...
-+ * $ gdb
-+ * ...
-+ * (gdb) target remote localhost:1234
-+ * ...
-+ * (gdb) print ((char *) *(unsigned int *) ((unsigned int) $rsp & ~8191)) +
-+ * 0x2c0
-+ * $9 = 0xc094062c "swapper"
-+ * (gdb) print (char *) (*(unsigned int *) (((char *) *(unsigned int *)
-+ * ((unsigned int) $rsp & ~8191)) + 0x1a0) - 0x1a0) + 0x2c0
-+ * $10 = 0xdf87cee0 "init"
-+ * ...
-+ */
-+
-+#define CAP_SYS_RAWIO 17
-+
-+#define THREAD_SIZE (TARGET_PAGE_SIZE << 1)
-+static ram_addr_t x86_current_thread(void)
-+{
-+ return env->regs[R_ESP] & ~(THREAD_SIZE - 1);
-+}
-+
-+static ram_addr_t x86_current_task(void)
-+{
-+ return *(uint32_t *) get_phys_mem_addr(env,
-+ x86_current_thread() + THREADINFO_TASK_OFFSET);
-+}
-+
-+static ram_addr_t x86_current_io_ctx(void)
-+{
-+ return *(uint32_t *) get_phys_mem_addr(env,
-+ x86_current_task() + TASKSTRUCT_IO_CTX_OFFSET);
-+}
-+
-+static ram_addr_t x86_task_name(ram_addr_t proc)
-+{
-+ return x86_current_task() + TASKSTRUCT_COMM_OFFSET;
-+}
-+
-+static ram_addr_t x86_task_next(ram_addr_t proc)
-+{
-+ return *(uint32_t *) get_phys_mem_addr(env,
-+ x86_current_task() + TASKSTRUCT_NEXT_OFFSET) -
-+ TASKSTRUCT_NEXT_OFFSET;
-+}
-+
-+static void x86_cap_set(ram_addr_t caps, int cap)
-+{
-+ int offset = cap >> 5;
-+ int mask = 1 << (cap & 31);
-+
-+ *(uint32_t *) get_phys_mem_addr(env, caps + offset) |= mask;
-+}
-+
-+static void x86_cred_cap_set(ram_addr_t creds, int cap)
-+{
-+ x86_cap_set(creds + CRED_CAPINH_OFFSET, cap);
-+ x86_cap_set(creds + CRED_CAPPER_OFFSET, cap);
-+ x86_cap_set(creds + CRED_CAPEFF_OFFSET, cap);
-+ x86_cap_set(creds + CRED_CAPBST_OFFSET, cap);
-+}
-+
-+static void x86_task_cap_set(ram_addr_t proc, int cap)
-+{
-+ x86_cred_cap_set(*(uint32_t *) get_phys_mem_addr(env,
-+ proc + TASKSTRUCT_RCRED_OFFSET), cap);
-+ x86_cred_cap_set(*(uint32_t *) get_phys_mem_addr(env,
-+ proc + TASKSTRUCT_CRED_OFFSET), cap);
-+}
-+
-+#include "kvm.h"
-+
-+/* The putting and getting of the register set seems to incure a too
-+ * high overhead. It's at least 4 ioctl's each. */
-+#if 0
-+static void opengl_ioport_write(void *data, uint32_t addr, uint32_t val)
-+{
-+ /* Ignore the first outb after iopl which is emulated by the kernel. */
-+ if (val == (uint8_t) -1)
-+ return;
-+
-+ if (kvm_enabled())
-+ kvm_arch_get_registers(env);
-+ doing_opengl = 1;
-+ env->regs[R_EAX] =
-+ decode_call(env, env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX],
-+ env->regs[R_ESI], env->regs[R_EDI]);
-+ doing_opengl = 0;
-+ if (kvm_enabled())
-+ kvm_arch_put_registers(env);
-+}
-+#else
-+static void get_regs(void)
-+{
-+ /* We only really need the eflags and cr[0..4] */
-+ if (kvm_enabled())
-+ kvm_get_sregs(env);
-+}
-+
-+static void opengl_ioport_write(void *data, uint32_t addr, uint32_t val)
-+{
-+ uint64_t *params;
-+ int ret;
-+
-+ /* Only need to fetch the registers after a guest's context switch...
-+ * the problem is, to find out about context switches we already need
-+ * to fetch rsp
-+ * TODO: pass the pid in val. the params pointer doesn't need to be
-+ * passed on all calls because it can be a global and be constant.
-+ */
-+ get_regs();
-+
-+ params = get_phys_mem_addr(env, (target_ulong) val);
-+
-+ /* Execute */
-+ doing_opengl = 1;
-+ ret = decode_call(env, le64_to_cpu(params[0]),
-+ le64_to_cpu(params[1]), le64_to_cpu(params[2]),
-+ le64_to_cpu(params[3]), le64_to_cpu(params[4]));
-+ doing_opengl = 0;
-+
-+ params[0] = cpu_to_le64(ret);
-+ params[5] = 0;
-+}
-+#endif
-+
-+static void opengl_ioport_write_first(void *data, uint32_t addr, uint32_t val)
-+{
-+ if (val != (uint32_t) -1)
-+ return;
-+
-+ /* Ignore the first outb after iopl which is emulated by the kernel. */
-+
-+ register_ioport_write(9996, 4, 4, opengl_ioport_write, (void *) 1);
-+}
-+
-+void io_register(void)
-+{
-+ register_ioport_write(9996, 4, 4, opengl_ioport_write_first, (void *) 1);
-+}
-+
-+void opengl_process_enable(void)
-+{
-+ ram_addr_t task;
-+ char *name;
-+ int newlevel = 3;
-+ uint32_t iopl = newlevel << 12;
-+ void *ioplptr;
-+
-+ if (kvm_enabled())
-+ kvm_arch_get_registers(env);
-+ allow_kernel = 1;
-+
-+ task = x86_current_task();
-+ x86_task_cap_set(task, CAP_SYS_RAWIO);
-+ name = get_phys_mem_addr(env, x86_task_name(task));
-+
-+ ioplptr = get_phys_mem_addr(env, task +
-+ TASKSTRUCT_THREAD_OFFSET + THREADSTRUCT_IOPL_OFFSET);
-+ ((uint32_t *) ioplptr)[0] = cpu_to_le32(iopl);
-+
-+ env->eflags &= ~0x3000;
-+ env->eflags |= newlevel << 12;
-+
-+ allow_kernel = 0;
-+ if (kvm_enabled())
-+ kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
-+
-+ printf("Granted OpenGL access to process '%s'\n", name);
-+
-+ io_register();
-+}
-+#endif
-Index: qemu-0.14.0/target-i386/kvm.c
-===================================================================
---- qemu-0.14.0.orig/target-i386/kvm.c
-+++ qemu-0.14.0/target-i386/kvm.c
-@@ -957,7 +957,7 @@ static int kvm_get_xcrs(CPUState *env)
- #endif
- }
-
--static int kvm_get_sregs(CPUState *env)
-+int kvm_get_sregs(CPUState *env)
- {
- struct kvm_sregs sregs;
- uint32_t hflags;
-Index: qemu-0.14.0/target-i386/mesa_enums.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/mesa_enums.c
-@@ -0,0 +1,4890 @@
-+/* DO NOT EDIT - This file generated automatically by gl_enums.py (from Mesa) script */
-+
-+/*
-+ * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
-+ * All Rights Reserved.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a
-+ * copy of this software and associated documentation files (the "Software"),
-+ * to deal in the Software without restriction, including without limitation
-+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
-+ * and/or sell copies of the Software, and to permit persons to whom the
-+ * Software is furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice (including the next
-+ * paragraph) shall be included in all copies or substantial portions of the
-+ * Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
-+ * BRIAN PAUL,
-+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-+ * SOFTWARE.
-+ */
-+
-+#include "glheader.h"
-+#include "enums.h"
-+#include "imports.h"
-+
-+typedef struct {
-+ size_t offset;
-+ int n;
-+} enum_elt;
-+
-+LONGSTRING static const char enum_string_table[] =
-+ "GL_2D\0"
-+ "GL_2_BYTES\0"
-+ "GL_3D\0"
-+ "GL_3D_COLOR\0"
-+ "GL_3D_COLOR_TEXTURE\0"
-+ "GL_3_BYTES\0"
-+ "GL_4D_COLOR_TEXTURE\0"
-+ "GL_4_BYTES\0"
-+ "GL_ACCUM\0"
-+ "GL_ACCUM_ALPHA_BITS\0"
-+ "GL_ACCUM_BLUE_BITS\0"
-+ "GL_ACCUM_BUFFER_BIT\0"
-+ "GL_ACCUM_CLEAR_VALUE\0"
-+ "GL_ACCUM_GREEN_BITS\0"
-+ "GL_ACCUM_RED_BITS\0"
-+ "GL_ACTIVE_ATTRIBUTES\0"
-+ "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH\0"
-+ "GL_ACTIVE_STENCIL_FACE_EXT\0"
-+ "GL_ACTIVE_TEXTURE\0"
-+ "GL_ACTIVE_TEXTURE_ARB\0"
-+ "GL_ACTIVE_UNIFORMS\0"
-+ "GL_ACTIVE_UNIFORM_MAX_LENGTH\0"
-+ "GL_ACTIVE_VERTEX_UNITS_ARB\0"
-+ "GL_ADD\0"
-+ "GL_ADD_SIGNED\0"
-+ "GL_ADD_SIGNED_ARB\0"
-+ "GL_ADD_SIGNED_EXT\0"
-+ "GL_ALIASED_LINE_WIDTH_RANGE\0"
-+ "GL_ALIASED_POINT_SIZE_RANGE\0"
-+ "GL_ALL_ATTRIB_BITS\0"
-+ "GL_ALL_CLIENT_ATTRIB_BITS\0"
-+ "GL_ALPHA\0"
-+ "GL_ALPHA12\0"
-+ "GL_ALPHA12_EXT\0"
-+ "GL_ALPHA16\0"
-+ "GL_ALPHA16_EXT\0"
-+ "GL_ALPHA4\0"
-+ "GL_ALPHA4_EXT\0"
-+ "GL_ALPHA8\0"
-+ "GL_ALPHA8_EXT\0"
-+ "GL_ALPHA_BIAS\0"
-+ "GL_ALPHA_BITS\0"
-+ "GL_ALPHA_SCALE\0"
-+ "GL_ALPHA_TEST\0"
-+ "GL_ALPHA_TEST_FUNC\0"
-+ "GL_ALPHA_TEST_REF\0"
-+ "GL_ALWAYS\0"
-+ "GL_AMBIENT\0"
-+ "GL_AMBIENT_AND_DIFFUSE\0"
-+ "GL_AND\0"
-+ "GL_AND_INVERTED\0"
-+ "GL_AND_REVERSE\0"
-+ "GL_ARRAY_BUFFER\0"
-+ "GL_ARRAY_BUFFER_ARB\0"
-+ "GL_ARRAY_BUFFER_BINDING\0"
-+ "GL_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_ATTACHED_SHADERS\0"
-+ "GL_ATTRIB_ARRAY_POINTER_NV\0"
-+ "GL_ATTRIB_ARRAY_SIZE_NV\0"
-+ "GL_ATTRIB_ARRAY_STRIDE_NV\0"
-+ "GL_ATTRIB_ARRAY_TYPE_NV\0"
-+ "GL_ATTRIB_STACK_DEPTH\0"
-+ "GL_AUTO_NORMAL\0"
-+ "GL_AUX0\0"
-+ "GL_AUX1\0"
-+ "GL_AUX2\0"
-+ "GL_AUX3\0"
-+ "GL_AUX_BUFFERS\0"
-+ "GL_BACK\0"
-+ "GL_BACK_LEFT\0"
-+ "GL_BACK_RIGHT\0"
-+ "GL_BGR\0"
-+ "GL_BGRA\0"
-+ "GL_BITMAP\0"
-+ "GL_BITMAP_TOKEN\0"
-+ "GL_BLEND\0"
-+ "GL_BLEND_COLOR\0"
-+ "GL_BLEND_COLOR_EXT\0"
-+ "GL_BLEND_DST\0"
-+ "GL_BLEND_DST_ALPHA\0"
-+ "GL_BLEND_DST_RGB\0"
-+ "GL_BLEND_EQUATION\0"
-+ "GL_BLEND_EQUATION_ALPHA\0"
-+ "GL_BLEND_EQUATION_ALPHA_EXT\0"
-+ "GL_BLEND_EQUATION_EXT\0"
-+ "GL_BLEND_EQUATION_RGB_EXT\0"
-+ "GL_BLEND_SRC\0"
-+ "GL_BLEND_SRC_ALPHA\0"
-+ "GL_BLEND_SRC_RGB\0"
-+ "GL_BLUE\0"
-+ "GL_BLUE_BIAS\0"
-+ "GL_BLUE_BITS\0"
-+ "GL_BLUE_SCALE\0"
-+ "GL_BOOL\0"
-+ "GL_BOOL_ARB\0"
-+ "GL_BOOL_VEC2\0"
-+ "GL_BOOL_VEC2_ARB\0"
-+ "GL_BOOL_VEC3\0"
-+ "GL_BOOL_VEC3_ARB\0"
-+ "GL_BOOL_VEC4\0"
-+ "GL_BOOL_VEC4_ARB\0"
-+ "GL_BUFFER_ACCESS\0"
-+ "GL_BUFFER_ACCESS_ARB\0"
-+ "GL_BUFFER_MAPPED\0"
-+ "GL_BUFFER_MAPPED_ARB\0"
-+ "GL_BUFFER_MAP_POINTER\0"
-+ "GL_BUFFER_MAP_POINTER_ARB\0"
-+ "GL_BUFFER_SIZE\0"
-+ "GL_BUFFER_SIZE_ARB\0"
-+ "GL_BUFFER_USAGE\0"
-+ "GL_BUFFER_USAGE_ARB\0"
-+ "GL_BYTE\0"
-+ "GL_C3F_V3F\0"
-+ "GL_C4F_N3F_V3F\0"
-+ "GL_C4UB_V2F\0"
-+ "GL_C4UB_V3F\0"
-+ "GL_CCW\0"
-+ "GL_CLAMP\0"
-+ "GL_CLAMP_TO_BORDER\0"
-+ "GL_CLAMP_TO_BORDER_ARB\0"
-+ "GL_CLAMP_TO_BORDER_SGIS\0"
-+ "GL_CLAMP_TO_EDGE\0"
-+ "GL_CLAMP_TO_EDGE_SGIS\0"
-+ "GL_CLEAR\0"
-+ "GL_CLIENT_ACTIVE_TEXTURE\0"
-+ "GL_CLIENT_ACTIVE_TEXTURE_ARB\0"
-+ "GL_CLIENT_ALL_ATTRIB_BITS\0"
-+ "GL_CLIENT_ATTRIB_STACK_DEPTH\0"
-+ "GL_CLIENT_PIXEL_STORE_BIT\0"
-+ "GL_CLIENT_VERTEX_ARRAY_BIT\0"
-+ "GL_CLIP_PLANE0\0"
-+ "GL_CLIP_PLANE1\0"
-+ "GL_CLIP_PLANE2\0"
-+ "GL_CLIP_PLANE3\0"
-+ "GL_CLIP_PLANE4\0"
-+ "GL_CLIP_PLANE5\0"
-+ "GL_CLIP_VOLUME_CLIPPING_HINT_EXT\0"
-+ "GL_COEFF\0"
-+ "GL_COLOR\0"
-+ "GL_COLOR_ARRAY\0"
-+ "GL_COLOR_ARRAY_BUFFER_BINDING\0"
-+ "GL_COLOR_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_COLOR_ARRAY_POINTER\0"
-+ "GL_COLOR_ARRAY_SIZE\0"
-+ "GL_COLOR_ARRAY_STRIDE\0"
-+ "GL_COLOR_ARRAY_TYPE\0"
-+ "GL_COLOR_ATTACHMENT0_EXT\0"
-+ "GL_COLOR_ATTACHMENT10_EXT\0"
-+ "GL_COLOR_ATTACHMENT11_EXT\0"
-+ "GL_COLOR_ATTACHMENT12_EXT\0"
-+ "GL_COLOR_ATTACHMENT13_EXT\0"
-+ "GL_COLOR_ATTACHMENT14_EXT\0"
-+ "GL_COLOR_ATTACHMENT15_EXT\0"
-+ "GL_COLOR_ATTACHMENT1_EXT\0"
-+ "GL_COLOR_ATTACHMENT2_EXT\0"
-+ "GL_COLOR_ATTACHMENT3_EXT\0"
-+ "GL_COLOR_ATTACHMENT4_EXT\0"
-+ "GL_COLOR_ATTACHMENT5_EXT\0"
-+ "GL_COLOR_ATTACHMENT6_EXT\0"
-+ "GL_COLOR_ATTACHMENT7_EXT\0"
-+ "GL_COLOR_ATTACHMENT8_EXT\0"
-+ "GL_COLOR_ATTACHMENT9_EXT\0"
-+ "GL_COLOR_BUFFER_BIT\0"
-+ "GL_COLOR_CLEAR_VALUE\0"
-+ "GL_COLOR_INDEX\0"
-+ "GL_COLOR_INDEXES\0"
-+ "GL_COLOR_LOGIC_OP\0"
-+ "GL_COLOR_MATERIAL\0"
-+ "GL_COLOR_MATERIAL_FACE\0"
-+ "GL_COLOR_MATERIAL_PARAMETER\0"
-+ "GL_COLOR_MATRIX\0"
-+ "GL_COLOR_MATRIX_SGI\0"
-+ "GL_COLOR_MATRIX_STACK_DEPTH\0"
-+ "GL_COLOR_MATRIX_STACK_DEPTH_SGI\0"
-+ "GL_COLOR_SUM\0"
-+ "GL_COLOR_SUM_ARB\0"
-+ "GL_COLOR_TABLE\0"
-+ "GL_COLOR_TABLE_ALPHA_SIZE\0"
-+ "GL_COLOR_TABLE_ALPHA_SIZE_EXT\0"
-+ "GL_COLOR_TABLE_ALPHA_SIZE_SGI\0"
-+ "GL_COLOR_TABLE_BIAS\0"
-+ "GL_COLOR_TABLE_BIAS_SGI\0"
-+ "GL_COLOR_TABLE_BLUE_SIZE\0"
-+ "GL_COLOR_TABLE_BLUE_SIZE_EXT\0"
-+ "GL_COLOR_TABLE_BLUE_SIZE_SGI\0"
-+ "GL_COLOR_TABLE_FORMAT\0"
-+ "GL_COLOR_TABLE_FORMAT_EXT\0"
-+ "GL_COLOR_TABLE_FORMAT_SGI\0"
-+ "GL_COLOR_TABLE_GREEN_SIZE\0"
-+ "GL_COLOR_TABLE_GREEN_SIZE_EXT\0"
-+ "GL_COLOR_TABLE_GREEN_SIZE_SGI\0"
-+ "GL_COLOR_TABLE_INTENSITY_SIZE\0"
-+ "GL_COLOR_TABLE_INTENSITY_SIZE_EXT\0"
-+ "GL_COLOR_TABLE_INTENSITY_SIZE_SGI\0"
-+ "GL_COLOR_TABLE_LUMINANCE_SIZE\0"
-+ "GL_COLOR_TABLE_LUMINANCE_SIZE_EXT\0"
-+ "GL_COLOR_TABLE_LUMINANCE_SIZE_SGI\0"
-+ "GL_COLOR_TABLE_RED_SIZE\0"
-+ "GL_COLOR_TABLE_RED_SIZE_EXT\0"
-+ "GL_COLOR_TABLE_RED_SIZE_SGI\0"
-+ "GL_COLOR_TABLE_SCALE\0"
-+ "GL_COLOR_TABLE_SCALE_SGI\0"
-+ "GL_COLOR_TABLE_WIDTH\0"
-+ "GL_COLOR_TABLE_WIDTH_EXT\0"
-+ "GL_COLOR_TABLE_WIDTH_SGI\0"
-+ "GL_COLOR_WRITEMASK\0"
-+ "GL_COMBINE\0"
-+ "GL_COMBINE4\0"
-+ "GL_COMBINE_ALPHA\0"
-+ "GL_COMBINE_ALPHA_ARB\0"
-+ "GL_COMBINE_ALPHA_EXT\0"
-+ "GL_COMBINE_ARB\0"
-+ "GL_COMBINE_EXT\0"
-+ "GL_COMBINE_RGB\0"
-+ "GL_COMBINE_RGB_ARB\0"
-+ "GL_COMBINE_RGB_EXT\0"
-+ "GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT\0"
-+ "GL_COMPARE_R_TO_TEXTURE\0"
-+ "GL_COMPARE_R_TO_TEXTURE_ARB\0"
-+ "GL_COMPILE\0"
-+ "GL_COMPILE_AND_EXECUTE\0"
-+ "GL_COMPILE_STATUS\0"
-+ "GL_COMPRESSED_ALPHA\0"
-+ "GL_COMPRESSED_ALPHA_ARB\0"
-+ "GL_COMPRESSED_INTENSITY\0"
-+ "GL_COMPRESSED_INTENSITY_ARB\0"
-+ "GL_COMPRESSED_LUMINANCE\0"
-+ "GL_COMPRESSED_LUMINANCE_ALPHA\0"
-+ "GL_COMPRESSED_LUMINANCE_ALPHA_ARB\0"
-+ "GL_COMPRESSED_LUMINANCE_ARB\0"
-+ "GL_COMPRESSED_RGB\0"
-+ "GL_COMPRESSED_RGBA\0"
-+ "GL_COMPRESSED_RGBA_ARB\0"
-+ "GL_COMPRESSED_RGBA_FXT1_3DFX\0"
-+ "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT\0"
-+ "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT\0"
-+ "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT\0"
-+ "GL_COMPRESSED_RGB_ARB\0"
-+ "GL_COMPRESSED_RGB_FXT1_3DFX\0"
-+ "GL_COMPRESSED_RGB_S3TC_DXT1_EXT\0"
-+ "GL_COMPRESSED_TEXTURE_FORMATS\0"
-+ "GL_CONSTANT\0"
-+ "GL_CONSTANT_ALPHA\0"
-+ "GL_CONSTANT_ALPHA_EXT\0"
-+ "GL_CONSTANT_ARB\0"
-+ "GL_CONSTANT_ATTENUATION\0"
-+ "GL_CONSTANT_BORDER_HP\0"
-+ "GL_CONSTANT_COLOR\0"
-+ "GL_CONSTANT_COLOR_EXT\0"
-+ "GL_CONSTANT_EXT\0"
-+ "GL_CONVOLUTION_1D\0"
-+ "GL_CONVOLUTION_2D\0"
-+ "GL_CONVOLUTION_BORDER_COLOR\0"
-+ "GL_CONVOLUTION_BORDER_COLOR_HP\0"
-+ "GL_CONVOLUTION_BORDER_MODE\0"
-+ "GL_CONVOLUTION_BORDER_MODE_EXT\0"
-+ "GL_CONVOLUTION_FILTER_BIAS\0"
-+ "GL_CONVOLUTION_FILTER_BIAS_EXT\0"
-+ "GL_CONVOLUTION_FILTER_SCALE\0"
-+ "GL_CONVOLUTION_FILTER_SCALE_EXT\0"
-+ "GL_CONVOLUTION_FORMAT\0"
-+ "GL_CONVOLUTION_FORMAT_EXT\0"
-+ "GL_CONVOLUTION_HEIGHT\0"
-+ "GL_CONVOLUTION_HEIGHT_EXT\0"
-+ "GL_CONVOLUTION_WIDTH\0"
-+ "GL_CONVOLUTION_WIDTH_EXT\0"
-+ "GL_COORD_REPLACE\0"
-+ "GL_COORD_REPLACE_ARB\0"
-+ "GL_COORD_REPLACE_NV\0"
-+ "GL_COPY\0"
-+ "GL_COPY_INVERTED\0"
-+ "GL_COPY_PIXEL_TOKEN\0"
-+ "GL_CULL_FACE\0"
-+ "GL_CULL_FACE_MODE\0"
-+ "GL_CULL_VERTEX_EXT\0"
-+ "GL_CULL_VERTEX_EYE_POSITION_EXT\0"
-+ "GL_CULL_VERTEX_OBJECT_POSITION_EXT\0"
-+ "GL_CURRENT_ATTRIB_NV\0"
-+ "GL_CURRENT_BIT\0"
-+ "GL_CURRENT_COLOR\0"
-+ "GL_CURRENT_FOG_COORD\0"
-+ "GL_CURRENT_FOG_COORDINATE\0"
-+ "GL_CURRENT_INDEX\0"
-+ "GL_CURRENT_MATRIX_ARB\0"
-+ "GL_CURRENT_MATRIX_INDEX_ARB\0"
-+ "GL_CURRENT_MATRIX_NV\0"
-+ "GL_CURRENT_MATRIX_STACK_DEPTH_ARB\0"
-+ "GL_CURRENT_MATRIX_STACK_DEPTH_NV\0"
-+ "GL_CURRENT_NORMAL\0"
-+ "GL_CURRENT_PALETTE_MATRIX_ARB\0"
-+ "GL_CURRENT_PROGRAM\0"
-+ "GL_CURRENT_QUERY\0"
-+ "GL_CURRENT_QUERY_ARB\0"
-+ "GL_CURRENT_RASTER_COLOR\0"
-+ "GL_CURRENT_RASTER_DISTANCE\0"
-+ "GL_CURRENT_RASTER_INDEX\0"
-+ "GL_CURRENT_RASTER_POSITION\0"
-+ "GL_CURRENT_RASTER_POSITION_VALID\0"
-+ "GL_CURRENT_RASTER_TEXTURE_COORDS\0"
-+ "GL_CURRENT_SECONDARY_COLOR\0"
-+ "GL_CURRENT_TEXTURE_COORDS\0"
-+ "GL_CURRENT_VERTEX_ATTRIB\0"
-+ "GL_CURRENT_VERTEX_ATTRIB_ARB\0"
-+ "GL_CURRENT_WEIGHT_ARB\0"
-+ "GL_CW\0"
-+ "GL_DEBUG_ASSERT_MESA\0"
-+ "GL_DEBUG_OBJECT_MESA\0"
-+ "GL_DEBUG_PRINT_MESA\0"
-+ "GL_DECAL\0"
-+ "GL_DECR\0"
-+ "GL_DECR_WRAP\0"
-+ "GL_DECR_WRAP_EXT\0"
-+ "GL_DELETE_STATUS\0"
-+ "GL_DEPTH\0"
-+ "GL_DEPTH_ATTACHMENT_EXT\0"
-+ "GL_DEPTH_BIAS\0"
-+ "GL_DEPTH_BITS\0"
-+ "GL_DEPTH_BOUNDS_EXT\0"
-+ "GL_DEPTH_BOUNDS_TEST_EXT\0"
-+ "GL_DEPTH_BUFFER_BIT\0"
-+ "GL_DEPTH_CLAMP_NV\0"
-+ "GL_DEPTH_CLEAR_VALUE\0"
-+ "GL_DEPTH_COMPONENT\0"
-+ "GL_DEPTH_COMPONENT16\0"
-+ "GL_DEPTH_COMPONENT16_ARB\0"
-+ "GL_DEPTH_COMPONENT16_SGIX\0"
-+ "GL_DEPTH_COMPONENT24\0"
-+ "GL_DEPTH_COMPONENT24_ARB\0"
-+ "GL_DEPTH_COMPONENT24_SGIX\0"
-+ "GL_DEPTH_COMPONENT32\0"
-+ "GL_DEPTH_COMPONENT32_ARB\0"
-+ "GL_DEPTH_COMPONENT32_SGIX\0"
-+ "GL_DEPTH_FUNC\0"
-+ "GL_DEPTH_RANGE\0"
-+ "GL_DEPTH_SCALE\0"
-+ "GL_DEPTH_STENCIL_NV\0"
-+ "GL_DEPTH_STENCIL_TO_BGRA_NV\0"
-+ "GL_DEPTH_STENCIL_TO_RGBA_NV\0"
-+ "GL_DEPTH_TEST\0"
-+ "GL_DEPTH_TEXTURE_MODE\0"
-+ "GL_DEPTH_TEXTURE_MODE_ARB\0"
-+ "GL_DEPTH_WRITEMASK\0"
-+ "GL_DIFFUSE\0"
-+ "GL_DITHER\0"
-+ "GL_DOMAIN\0"
-+ "GL_DONT_CARE\0"
-+ "GL_DOT3_RGB\0"
-+ "GL_DOT3_RGBA\0"
-+ "GL_DOT3_RGBA_ARB\0"
-+ "GL_DOT3_RGBA_EXT\0"
-+ "GL_DOT3_RGB_ARB\0"
-+ "GL_DOT3_RGB_EXT\0"
-+ "GL_DOUBLE\0"
-+ "GL_DOUBLEBUFFER\0"
-+ "GL_DRAW_BUFFER\0"
-+ "GL_DRAW_BUFFER0\0"
-+ "GL_DRAW_BUFFER0_ARB\0"
-+ "GL_DRAW_BUFFER0_ATI\0"
-+ "GL_DRAW_BUFFER1\0"
-+ "GL_DRAW_BUFFER10\0"
-+ "GL_DRAW_BUFFER10_ARB\0"
-+ "GL_DRAW_BUFFER10_ATI\0"
-+ "GL_DRAW_BUFFER11\0"
-+ "GL_DRAW_BUFFER11_ARB\0"
-+ "GL_DRAW_BUFFER11_ATI\0"
-+ "GL_DRAW_BUFFER12\0"
-+ "GL_DRAW_BUFFER12_ARB\0"
-+ "GL_DRAW_BUFFER12_ATI\0"
-+ "GL_DRAW_BUFFER13\0"
-+ "GL_DRAW_BUFFER13_ARB\0"
-+ "GL_DRAW_BUFFER13_ATI\0"
-+ "GL_DRAW_BUFFER14\0"
-+ "GL_DRAW_BUFFER14_ARB\0"
-+ "GL_DRAW_BUFFER14_ATI\0"
-+ "GL_DRAW_BUFFER15\0"
-+ "GL_DRAW_BUFFER15_ARB\0"
-+ "GL_DRAW_BUFFER15_ATI\0"
-+ "GL_DRAW_BUFFER1_ARB\0"
-+ "GL_DRAW_BUFFER1_ATI\0"
-+ "GL_DRAW_BUFFER2\0"
-+ "GL_DRAW_BUFFER2_ARB\0"
-+ "GL_DRAW_BUFFER2_ATI\0"
-+ "GL_DRAW_BUFFER3\0"
-+ "GL_DRAW_BUFFER3_ARB\0"
-+ "GL_DRAW_BUFFER3_ATI\0"
-+ "GL_DRAW_BUFFER4\0"
-+ "GL_DRAW_BUFFER4_ARB\0"
-+ "GL_DRAW_BUFFER4_ATI\0"
-+ "GL_DRAW_BUFFER5\0"
-+ "GL_DRAW_BUFFER5_ARB\0"
-+ "GL_DRAW_BUFFER5_ATI\0"
-+ "GL_DRAW_BUFFER6\0"
-+ "GL_DRAW_BUFFER6_ARB\0"
-+ "GL_DRAW_BUFFER6_ATI\0"
-+ "GL_DRAW_BUFFER7\0"
-+ "GL_DRAW_BUFFER7_ARB\0"
-+ "GL_DRAW_BUFFER7_ATI\0"
-+ "GL_DRAW_BUFFER8\0"
-+ "GL_DRAW_BUFFER8_ARB\0"
-+ "GL_DRAW_BUFFER8_ATI\0"
-+ "GL_DRAW_BUFFER9\0"
-+ "GL_DRAW_BUFFER9_ARB\0"
-+ "GL_DRAW_BUFFER9_ATI\0"
-+ "GL_DRAW_FRAMEBUFFER_BINDING_EXT\0"
-+ "GL_DRAW_FRAMEBUFFER_EXT\0"
-+ "GL_DRAW_PIXEL_TOKEN\0"
-+ "GL_DST_ALPHA\0"
-+ "GL_DST_COLOR\0"
-+ "GL_DYNAMIC_COPY\0"
-+ "GL_DYNAMIC_COPY_ARB\0"
-+ "GL_DYNAMIC_DRAW\0"
-+ "GL_DYNAMIC_DRAW_ARB\0"
-+ "GL_DYNAMIC_READ\0"
-+ "GL_DYNAMIC_READ_ARB\0"
-+ "GL_EDGE_FLAG\0"
-+ "GL_EDGE_FLAG_ARRAY\0"
-+ "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING\0"
-+ "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_EDGE_FLAG_ARRAY_POINTER\0"
-+ "GL_EDGE_FLAG_ARRAY_STRIDE\0"
-+ "GL_ELEMENT_ARRAY_BUFFER\0"
-+ "GL_ELEMENT_ARRAY_BUFFER_ARB\0"
-+ "GL_ELEMENT_ARRAY_BUFFER_BINDING\0"
-+ "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_EMISSION\0"
-+ "GL_ENABLE_BIT\0"
-+ "GL_EQUAL\0"
-+ "GL_EQUIV\0"
-+ "GL_EVAL_BIT\0"
-+ "GL_EXP\0"
-+ "GL_EXP2\0"
-+ "GL_EXTENSIONS\0"
-+ "GL_EYE_LINEAR\0"
-+ "GL_EYE_PLANE\0"
-+ "GL_EYE_PLANE_ABSOLUTE_NV\0"
-+ "GL_EYE_RADIAL_NV\0"
-+ "GL_FALSE\0"
-+ "GL_FASTEST\0"
-+ "GL_FEEDBACK\0"
-+ "GL_FEEDBACK_BUFFER_POINTER\0"
-+ "GL_FEEDBACK_BUFFER_SIZE\0"
-+ "GL_FEEDBACK_BUFFER_TYPE\0"
-+ "GL_FILL\0"
-+ "GL_FLAT\0"
-+ "GL_FLOAT\0"
-+ "GL_FLOAT_MAT2\0"
-+ "GL_FLOAT_MAT2_ARB\0"
-+ "GL_FLOAT_MAT3\0"
-+ "GL_FLOAT_MAT3_ARB\0"
-+ "GL_FLOAT_MAT4\0"
-+ "GL_FLOAT_MAT4_ARB\0"
-+ "GL_FLOAT_VEC2\0"
-+ "GL_FLOAT_VEC2_ARB\0"
-+ "GL_FLOAT_VEC3\0"
-+ "GL_FLOAT_VEC3_ARB\0"
-+ "GL_FLOAT_VEC4\0"
-+ "GL_FLOAT_VEC4_ARB\0"
-+ "GL_FOG\0"
-+ "GL_FOG_BIT\0"
-+ "GL_FOG_COLOR\0"
-+ "GL_FOG_COORD\0"
-+ "GL_FOG_COORDINATE\0"
-+ "GL_FOG_COORDINATE_ARRAY\0"
-+ "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING\0"
-+ "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_FOG_COORDINATE_ARRAY_POINTER\0"
-+ "GL_FOG_COORDINATE_ARRAY_STRIDE\0"
-+ "GL_FOG_COORDINATE_ARRAY_TYPE\0"
-+ "GL_FOG_COORDINATE_SOURCE\0"
-+ "GL_FOG_COORD_ARRAY\0"
-+ "GL_FOG_COORD_ARRAY_BUFFER_BINDING\0"
-+ "GL_FOG_COORD_ARRAY_POINTER\0"
-+ "GL_FOG_COORD_ARRAY_STRIDE\0"
-+ "GL_FOG_COORD_ARRAY_TYPE\0"
-+ "GL_FOG_COORD_SRC\0"
-+ "GL_FOG_DENSITY\0"
-+ "GL_FOG_DISTANCE_MODE_NV\0"
-+ "GL_FOG_END\0"
-+ "GL_FOG_HINT\0"
-+ "GL_FOG_INDEX\0"
-+ "GL_FOG_MODE\0"
-+ "GL_FOG_OFFSET_SGIX\0"
-+ "GL_FOG_OFFSET_VALUE_SGIX\0"
-+ "GL_FOG_START\0"
-+ "GL_FRAGMENT_DEPTH\0"
-+ "GL_FRAGMENT_PROGRAM_ARB\0"
-+ "GL_FRAGMENT_SHADER\0"
-+ "GL_FRAGMENT_SHADER_ARB\0"
-+ "GL_FRAGMENT_SHADER_DERIVATIVE_HINT\0"
-+ "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT\0"
-+ "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT\0"
-+ "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT\0"
-+ "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT\0"
-+ "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT\0"
-+ "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT\0"
-+ "GL_FRAMEBUFFER_BINDING_EXT\0"
-+ "GL_FRAMEBUFFER_COMPLETE_EXT\0"
-+ "GL_FRAMEBUFFER_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\0"
-+ "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\0"
-+ "GL_FRAMEBUFFER_STATUS_ERROR_EXT\0"
-+ "GL_FRAMEBUFFER_UNSUPPORTED_EXT\0"
-+ "GL_FRONT\0"
-+ "GL_FRONT_AND_BACK\0"
-+ "GL_FRONT_FACE\0"
-+ "GL_FRONT_LEFT\0"
-+ "GL_FRONT_RIGHT\0"
-+ "GL_FUNC_ADD\0"
-+ "GL_FUNC_ADD_EXT\0"
-+ "GL_FUNC_REVERSE_SUBTRACT\0"
-+ "GL_FUNC_REVERSE_SUBTRACT_EXT\0"
-+ "GL_FUNC_SUBTRACT\0"
-+ "GL_FUNC_SUBTRACT_EXT\0"
-+ "GL_GENERATE_MIPMAP\0"
-+ "GL_GENERATE_MIPMAP_HINT\0"
-+ "GL_GENERATE_MIPMAP_HINT_SGIS\0"
-+ "GL_GENERATE_MIPMAP_SGIS\0"
-+ "GL_GEQUAL\0"
-+ "GL_GL_BLEND_EQUATION_RGB\0"
-+ "GL_GL_COMPRESSED_SLUMINANCE\0"
-+ "GL_GL_COMPRESSED_SLUMINANCE_ALPHA\0"
-+ "GL_GL_COMPRESSED_SRGB\0"
-+ "GL_GL_COMPRESSED_SRGB_ALPHA\0"
-+ "GL_GL_CURRENT_RASTER_SECONDARY_COLOR\0"
-+ "GL_GL_FLOAT_MAT2x3\0"
-+ "GL_GL_FLOAT_MAT2x4\0"
-+ "GL_GL_FLOAT_MAT3x2\0"
-+ "GL_GL_FLOAT_MAT3x4\0"
-+ "GL_GL_FLOAT_MAT4x2\0"
-+ "GL_GL_FLOAT_MAT4x3\0"
-+ "GL_GL_PIXEL_PACK_BUFFER\0"
-+ "GL_GL_PIXEL_PACK_BUFFER_BINDING\0"
-+ "GL_GL_PIXEL_UNPACK_BUFFER\0"
-+ "GL_GL_PIXEL_UNPACK_BUFFER_BINDING\0"
-+ "GL_GL_SLUMINANCE\0"
-+ "GL_GL_SLUMINANCE8\0"
-+ "GL_GL_SLUMINANCE8_ALPHA8\0"
-+ "GL_GL_SLUMINANCE_ALPHA\0"
-+ "GL_GL_SRGB\0"
-+ "GL_GL_SRGB8\0"
-+ "GL_GL_SRGB8_ALPHA8\0"
-+ "GL_GL_SRGB_ALPHA\0"
-+ "GL_GREATER\0"
-+ "GL_GREEN\0"
-+ "GL_GREEN_BIAS\0"
-+ "GL_GREEN_BITS\0"
-+ "GL_GREEN_SCALE\0"
-+ "GL_HINT_BIT\0"
-+ "GL_HISTOGRAM\0"
-+ "GL_HISTOGRAM_ALPHA_SIZE\0"
-+ "GL_HISTOGRAM_ALPHA_SIZE_EXT\0"
-+ "GL_HISTOGRAM_BLUE_SIZE\0"
-+ "GL_HISTOGRAM_BLUE_SIZE_EXT\0"
-+ "GL_HISTOGRAM_EXT\0"
-+ "GL_HISTOGRAM_FORMAT\0"
-+ "GL_HISTOGRAM_FORMAT_EXT\0"
-+ "GL_HISTOGRAM_GREEN_SIZE\0"
-+ "GL_HISTOGRAM_GREEN_SIZE_EXT\0"
-+ "GL_HISTOGRAM_LUMINANCE_SIZE\0"
-+ "GL_HISTOGRAM_LUMINANCE_SIZE_EXT\0"
-+ "GL_HISTOGRAM_RED_SIZE\0"
-+ "GL_HISTOGRAM_RED_SIZE_EXT\0"
-+ "GL_HISTOGRAM_SINK\0"
-+ "GL_HISTOGRAM_SINK_EXT\0"
-+ "GL_HISTOGRAM_WIDTH\0"
-+ "GL_HISTOGRAM_WIDTH_EXT\0"
-+ "GL_IDENTITY_NV\0"
-+ "GL_IGNORE_BORDER_HP\0"
-+ "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES\0"
-+ "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES\0"
-+ "GL_INCR\0"
-+ "GL_INCR_WRAP\0"
-+ "GL_INCR_WRAP_EXT\0"
-+ "GL_INDEX_ARRAY\0"
-+ "GL_INDEX_ARRAY_BUFFER_BINDING\0"
-+ "GL_INDEX_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_INDEX_ARRAY_POINTER\0"
-+ "GL_INDEX_ARRAY_STRIDE\0"
-+ "GL_INDEX_ARRAY_TYPE\0"
-+ "GL_INDEX_BITS\0"
-+ "GL_INDEX_CLEAR_VALUE\0"
-+ "GL_INDEX_LOGIC_OP\0"
-+ "GL_INDEX_MODE\0"
-+ "GL_INDEX_OFFSET\0"
-+ "GL_INDEX_SHIFT\0"
-+ "GL_INDEX_WRITEMASK\0"
-+ "GL_INFO_LOG_LENGTH\0"
-+ "GL_INT\0"
-+ "GL_INTENSITY\0"
-+ "GL_INTENSITY12\0"
-+ "GL_INTENSITY12_EXT\0"
-+ "GL_INTENSITY16\0"
-+ "GL_INTENSITY16_EXT\0"
-+ "GL_INTENSITY4\0"
-+ "GL_INTENSITY4_EXT\0"
-+ "GL_INTENSITY8\0"
-+ "GL_INTENSITY8_EXT\0"
-+ "GL_INTENSITY_EXT\0"
-+ "GL_INTERPOLATE\0"
-+ "GL_INTERPOLATE_ARB\0"
-+ "GL_INTERPOLATE_EXT\0"
-+ "GL_INT_VEC2\0"
-+ "GL_INT_VEC2_ARB\0"
-+ "GL_INT_VEC3\0"
-+ "GL_INT_VEC3_ARB\0"
-+ "GL_INT_VEC4\0"
-+ "GL_INT_VEC4_ARB\0"
-+ "GL_INVALID_ENUM\0"
-+ "GL_INVALID_FRAMEBUFFER_OPERATION_EXT\0"
-+ "GL_INVALID_OPERATION\0"
-+ "GL_INVALID_VALUE\0"
-+ "GL_INVERSE_NV\0"
-+ "GL_INVERSE_TRANSPOSE_NV\0"
-+ "GL_INVERT\0"
-+ "GL_KEEP\0"
-+ "GL_LEFT\0"
-+ "GL_LEQUAL\0"
-+ "GL_LESS\0"
-+ "GL_LIGHT0\0"
-+ "GL_LIGHT1\0"
-+ "GL_LIGHT2\0"
-+ "GL_LIGHT3\0"
-+ "GL_LIGHT4\0"
-+ "GL_LIGHT5\0"
-+ "GL_LIGHT6\0"
-+ "GL_LIGHT7\0"
-+ "GL_LIGHTING\0"
-+ "GL_LIGHTING_BIT\0"
-+ "GL_LIGHT_MODEL_AMBIENT\0"
-+ "GL_LIGHT_MODEL_COLOR_CONTROL\0"
-+ "GL_LIGHT_MODEL_COLOR_CONTROL_EXT\0"
-+ "GL_LIGHT_MODEL_LOCAL_VIEWER\0"
-+ "GL_LIGHT_MODEL_TWO_SIDE\0"
-+ "GL_LINE\0"
-+ "GL_LINEAR\0"
-+ "GL_LINEAR_ATTENUATION\0"
-+ "GL_LINEAR_CLIPMAP_LINEAR_SGIX\0"
-+ "GL_LINEAR_CLIPMAP_NEAREST_SGIX\0"
-+ "GL_LINEAR_MIPMAP_LINEAR\0"
-+ "GL_LINEAR_MIPMAP_NEAREST\0"
-+ "GL_LINES\0"
-+ "GL_LINE_BIT\0"
-+ "GL_LINE_LOOP\0"
-+ "GL_LINE_RESET_TOKEN\0"
-+ "GL_LINE_SMOOTH\0"
-+ "GL_LINE_SMOOTH_HINT\0"
-+ "GL_LINE_STIPPLE\0"
-+ "GL_LINE_STIPPLE_PATTERN\0"
-+ "GL_LINE_STIPPLE_REPEAT\0"
-+ "GL_LINE_STRIP\0"
-+ "GL_LINE_TOKEN\0"
-+ "GL_LINE_WIDTH\0"
-+ "GL_LINE_WIDTH_GRANULARITY\0"
-+ "GL_LINE_WIDTH_RANGE\0"
-+ "GL_LINK_STATUS\0"
-+ "GL_LIST_BASE\0"
-+ "GL_LIST_BIT\0"
-+ "GL_LIST_INDEX\0"
-+ "GL_LIST_MODE\0"
-+ "GL_LOAD\0"
-+ "GL_LOGIC_OP\0"
-+ "GL_LOGIC_OP_MODE\0"
-+ "GL_LOWER_LEFT\0"
-+ "GL_LUMINANCE\0"
-+ "GL_LUMINANCE12\0"
-+ "GL_LUMINANCE12_ALPHA12\0"
-+ "GL_LUMINANCE12_ALPHA12_EXT\0"
-+ "GL_LUMINANCE12_ALPHA4\0"
-+ "GL_LUMINANCE12_ALPHA4_EXT\0"
-+ "GL_LUMINANCE12_EXT\0"
-+ "GL_LUMINANCE16\0"
-+ "GL_LUMINANCE16_ALPHA16\0"
-+ "GL_LUMINANCE16_ALPHA16_EXT\0"
-+ "GL_LUMINANCE16_EXT\0"
-+ "GL_LUMINANCE4\0"
-+ "GL_LUMINANCE4_ALPHA4\0"
-+ "GL_LUMINANCE4_ALPHA4_EXT\0"
-+ "GL_LUMINANCE4_EXT\0"
-+ "GL_LUMINANCE6_ALPHA2\0"
-+ "GL_LUMINANCE6_ALPHA2_EXT\0"
-+ "GL_LUMINANCE8\0"
-+ "GL_LUMINANCE8_ALPHA8\0"
-+ "GL_LUMINANCE8_ALPHA8_EXT\0"
-+ "GL_LUMINANCE8_EXT\0"
-+ "GL_LUMINANCE_ALPHA\0"
-+ "GL_MAP1_COLOR_4\0"
-+ "GL_MAP1_GRID_DOMAIN\0"
-+ "GL_MAP1_GRID_SEGMENTS\0"
-+ "GL_MAP1_INDEX\0"
-+ "GL_MAP1_NORMAL\0"
-+ "GL_MAP1_TEXTURE_COORD_1\0"
-+ "GL_MAP1_TEXTURE_COORD_2\0"
-+ "GL_MAP1_TEXTURE_COORD_3\0"
-+ "GL_MAP1_TEXTURE_COORD_4\0"
-+ "GL_MAP1_VERTEX_3\0"
-+ "GL_MAP1_VERTEX_4\0"
-+ "GL_MAP1_VERTEX_ATTRIB0_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB10_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB11_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB12_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB13_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB14_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB15_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB1_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB2_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB3_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB4_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB5_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB6_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB7_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB8_4_NV\0"
-+ "GL_MAP1_VERTEX_ATTRIB9_4_NV\0"
-+ "GL_MAP2_COLOR_4\0"
-+ "GL_MAP2_GRID_DOMAIN\0"
-+ "GL_MAP2_GRID_SEGMENTS\0"
-+ "GL_MAP2_INDEX\0"
-+ "GL_MAP2_NORMAL\0"
-+ "GL_MAP2_TEXTURE_COORD_1\0"
-+ "GL_MAP2_TEXTURE_COORD_2\0"
-+ "GL_MAP2_TEXTURE_COORD_3\0"
-+ "GL_MAP2_TEXTURE_COORD_4\0"
-+ "GL_MAP2_VERTEX_3\0"
-+ "GL_MAP2_VERTEX_4\0"
-+ "GL_MAP2_VERTEX_ATTRIB0_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB10_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB11_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB12_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB13_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB14_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB15_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB1_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB2_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB3_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB4_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB5_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB6_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB7_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB8_4_NV\0"
-+ "GL_MAP2_VERTEX_ATTRIB9_4_NV\0"
-+ "GL_MAP_COLOR\0"
-+ "GL_MAP_STENCIL\0"
-+ "GL_MATRIX0_ARB\0"
-+ "GL_MATRIX0_NV\0"
-+ "GL_MATRIX10_ARB\0"
-+ "GL_MATRIX11_ARB\0"
-+ "GL_MATRIX12_ARB\0"
-+ "GL_MATRIX13_ARB\0"
-+ "GL_MATRIX14_ARB\0"
-+ "GL_MATRIX15_ARB\0"
-+ "GL_MATRIX16_ARB\0"
-+ "GL_MATRIX17_ARB\0"
-+ "GL_MATRIX18_ARB\0"
-+ "GL_MATRIX19_ARB\0"
-+ "GL_MATRIX1_ARB\0"
-+ "GL_MATRIX1_NV\0"
-+ "GL_MATRIX20_ARB\0"
-+ "GL_MATRIX21_ARB\0"
-+ "GL_MATRIX22_ARB\0"
-+ "GL_MATRIX23_ARB\0"
-+ "GL_MATRIX24_ARB\0"
-+ "GL_MATRIX25_ARB\0"
-+ "GL_MATRIX26_ARB\0"
-+ "GL_MATRIX27_ARB\0"
-+ "GL_MATRIX28_ARB\0"
-+ "GL_MATRIX29_ARB\0"
-+ "GL_MATRIX2_ARB\0"
-+ "GL_MATRIX2_NV\0"
-+ "GL_MATRIX30_ARB\0"
-+ "GL_MATRIX31_ARB\0"
-+ "GL_MATRIX3_ARB\0"
-+ "GL_MATRIX3_NV\0"
-+ "GL_MATRIX4_ARB\0"
-+ "GL_MATRIX4_NV\0"
-+ "GL_MATRIX5_ARB\0"
-+ "GL_MATRIX5_NV\0"
-+ "GL_MATRIX6_ARB\0"
-+ "GL_MATRIX6_NV\0"
-+ "GL_MATRIX7_ARB\0"
-+ "GL_MATRIX7_NV\0"
-+ "GL_MATRIX8_ARB\0"
-+ "GL_MATRIX9_ARB\0"
-+ "GL_MATRIX_INDEX_ARRAY_ARB\0"
-+ "GL_MATRIX_INDEX_ARRAY_POINTER_ARB\0"
-+ "GL_MATRIX_INDEX_ARRAY_SIZE_ARB\0"
-+ "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB\0"
-+ "GL_MATRIX_INDEX_ARRAY_TYPE_ARB\0"
-+ "GL_MATRIX_MODE\0"
-+ "GL_MATRIX_PALETTE_ARB\0"
-+ "GL_MAX\0"
-+ "GL_MAX_3D_TEXTURE_SIZE\0"
-+ "GL_MAX_ARRAY_TEXTURE_LAYERS_EXT\0"
-+ "GL_MAX_ATTRIB_STACK_DEPTH\0"
-+ "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH\0"
-+ "GL_MAX_CLIPMAP_DEPTH_SGIX\0"
-+ "GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX\0"
-+ "GL_MAX_CLIP_PLANES\0"
-+ "GL_MAX_COLOR_ATTACHMENTS_EXT\0"
-+ "GL_MAX_COLOR_MATRIX_STACK_DEPTH\0"
-+ "GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI\0"
-+ "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS\0"
-+ "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB\0"
-+ "GL_MAX_CONVOLUTION_HEIGHT\0"
-+ "GL_MAX_CONVOLUTION_HEIGHT_EXT\0"
-+ "GL_MAX_CONVOLUTION_WIDTH\0"
-+ "GL_MAX_CONVOLUTION_WIDTH_EXT\0"
-+ "GL_MAX_CUBE_MAP_TEXTURE_SIZE\0"
-+ "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB\0"
-+ "GL_MAX_DRAW_BUFFERS\0"
-+ "GL_MAX_DRAW_BUFFERS_ARB\0"
-+ "GL_MAX_DRAW_BUFFERS_ATI\0"
-+ "GL_MAX_ELEMENTS_INDICES\0"
-+ "GL_MAX_ELEMENTS_VERTICES\0"
-+ "GL_MAX_EVAL_ORDER\0"
-+ "GL_MAX_EXT\0"
-+ "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS\0"
-+ "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB\0"
-+ "GL_MAX_LIGHTS\0"
-+ "GL_MAX_LIST_NESTING\0"
-+ "GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB\0"
-+ "GL_MAX_MODELVIEW_STACK_DEPTH\0"
-+ "GL_MAX_NAME_STACK_DEPTH\0"
-+ "GL_MAX_PALETTE_MATRICES_ARB\0"
-+ "GL_MAX_PIXEL_MAP_TABLE\0"
-+ "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB\0"
-+ "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_ATTRIBS_ARB\0"
-+ "GL_MAX_PROGRAM_CALL_DEPTH_NV\0"
-+ "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB\0"
-+ "GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV\0"
-+ "GL_MAX_PROGRAM_IF_DEPTH_NV\0"
-+ "GL_MAX_PROGRAM_INSTRUCTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB\0"
-+ "GL_MAX_PROGRAM_LOOP_COUNT_NV\0"
-+ "GL_MAX_PROGRAM_LOOP_DEPTH_NV\0"
-+ "GL_MAX_PROGRAM_MATRICES_ARB\0"
-+ "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_PARAMETERS_ARB\0"
-+ "GL_MAX_PROGRAM_TEMPORARIES_ARB\0"
-+ "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB\0"
-+ "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB\0"
-+ "GL_MAX_PROJECTION_STACK_DEPTH\0"
-+ "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB\0"
-+ "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV\0"
-+ "GL_MAX_RENDERBUFFER_SIZE_EXT\0"
-+ "GL_MAX_SHININESS_NV\0"
-+ "GL_MAX_SPOT_EXPONENT_NV\0"
-+ "GL_MAX_TEXTURE_COORDS\0"
-+ "GL_MAX_TEXTURE_COORDS_ARB\0"
-+ "GL_MAX_TEXTURE_IMAGE_UNITS\0"
-+ "GL_MAX_TEXTURE_IMAGE_UNITS_ARB\0"
-+ "GL_MAX_TEXTURE_LOD_BIAS\0"
-+ "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT\0"
-+ "GL_MAX_TEXTURE_SIZE\0"
-+ "GL_MAX_TEXTURE_STACK_DEPTH\0"
-+ "GL_MAX_TEXTURE_UNITS\0"
-+ "GL_MAX_TEXTURE_UNITS_ARB\0"
-+ "GL_MAX_TRACK_MATRICES_NV\0"
-+ "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV\0"
-+ "GL_MAX_VARYING_FLOATS\0"
-+ "GL_MAX_VARYING_FLOATS_ARB\0"
-+ "GL_MAX_VERTEX_ATTRIBS\0"
-+ "GL_MAX_VERTEX_ATTRIBS_ARB\0"
-+ "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS\0"
-+ "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB\0"
-+ "GL_MAX_VERTEX_UNIFORM_COMPONENTS\0"
-+ "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB\0"
-+ "GL_MAX_VERTEX_UNITS_ARB\0"
-+ "GL_MAX_VIEWPORT_DIMS\0"
-+ "GL_MIN\0"
-+ "GL_MINMAX\0"
-+ "GL_MINMAX_EXT\0"
-+ "GL_MINMAX_FORMAT\0"
-+ "GL_MINMAX_FORMAT_EXT\0"
-+ "GL_MINMAX_SINK\0"
-+ "GL_MINMAX_SINK_EXT\0"
-+ "GL_MIN_EXT\0"
-+ "GL_MIRRORED_REPEAT\0"
-+ "GL_MIRRORED_REPEAT_ARB\0"
-+ "GL_MIRRORED_REPEAT_IBM\0"
-+ "GL_MIRROR_CLAMP_ATI\0"
-+ "GL_MIRROR_CLAMP_EXT\0"
-+ "GL_MIRROR_CLAMP_TO_BORDER_EXT\0"
-+ "GL_MIRROR_CLAMP_TO_EDGE_ATI\0"
-+ "GL_MIRROR_CLAMP_TO_EDGE_EXT\0"
-+ "GL_MODELVIEW\0"
-+ "GL_MODELVIEW0_ARB\0"
-+ "GL_MODELVIEW10_ARB\0"
-+ "GL_MODELVIEW11_ARB\0"
-+ "GL_MODELVIEW12_ARB\0"
-+ "GL_MODELVIEW13_ARB\0"
-+ "GL_MODELVIEW14_ARB\0"
-+ "GL_MODELVIEW15_ARB\0"
-+ "GL_MODELVIEW16_ARB\0"
-+ "GL_MODELVIEW17_ARB\0"
-+ "GL_MODELVIEW18_ARB\0"
-+ "GL_MODELVIEW19_ARB\0"
-+ "GL_MODELVIEW1_ARB\0"
-+ "GL_MODELVIEW20_ARB\0"
-+ "GL_MODELVIEW21_ARB\0"
-+ "GL_MODELVIEW22_ARB\0"
-+ "GL_MODELVIEW23_ARB\0"
-+ "GL_MODELVIEW24_ARB\0"
-+ "GL_MODELVIEW25_ARB\0"
-+ "GL_MODELVIEW26_ARB\0"
-+ "GL_MODELVIEW27_ARB\0"
-+ "GL_MODELVIEW28_ARB\0"
-+ "GL_MODELVIEW29_ARB\0"
-+ "GL_MODELVIEW2_ARB\0"
-+ "GL_MODELVIEW30_ARB\0"
-+ "GL_MODELVIEW31_ARB\0"
-+ "GL_MODELVIEW3_ARB\0"
-+ "GL_MODELVIEW4_ARB\0"
-+ "GL_MODELVIEW5_ARB\0"
-+ "GL_MODELVIEW6_ARB\0"
-+ "GL_MODELVIEW7_ARB\0"
-+ "GL_MODELVIEW8_ARB\0"
-+ "GL_MODELVIEW9_ARB\0"
-+ "GL_MODELVIEW_MATRIX\0"
-+ "GL_MODELVIEW_PROJECTION_NV\0"
-+ "GL_MODELVIEW_STACK_DEPTH\0"
-+ "GL_MODULATE\0"
-+ "GL_MODULATE_ADD_ATI\0"
-+ "GL_MODULATE_SIGNED_ADD_ATI\0"
-+ "GL_MODULATE_SUBTRACT_ATI\0"
-+ "GL_MULT\0"
-+ "GL_MULTISAMPLE\0"
-+ "GL_MULTISAMPLE_3DFX\0"
-+ "GL_MULTISAMPLE_ARB\0"
-+ "GL_MULTISAMPLE_BIT\0"
-+ "GL_MULTISAMPLE_BIT_3DFX\0"
-+ "GL_MULTISAMPLE_BIT_ARB\0"
-+ "GL_MULTISAMPLE_FILTER_HINT_NV\0"
-+ "GL_N3F_V3F\0"
-+ "GL_NAME_STACK_DEPTH\0"
-+ "GL_NAND\0"
-+ "GL_NEAREST\0"
-+ "GL_NEAREST_CLIPMAP_LINEAR_SGIX\0"
-+ "GL_NEAREST_CLIPMAP_NEAREST_SGIX\0"
-+ "GL_NEAREST_MIPMAP_LINEAR\0"
-+ "GL_NEAREST_MIPMAP_NEAREST\0"
-+ "GL_NEVER\0"
-+ "GL_NICEST\0"
-+ "GL_NONE\0"
-+ "GL_NOOP\0"
-+ "GL_NOR\0"
-+ "GL_NORMALIZE\0"
-+ "GL_NORMAL_ARRAY\0"
-+ "GL_NORMAL_ARRAY_BUFFER_BINDING\0"
-+ "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_NORMAL_ARRAY_POINTER\0"
-+ "GL_NORMAL_ARRAY_STRIDE\0"
-+ "GL_NORMAL_ARRAY_TYPE\0"
-+ "GL_NORMAL_MAP\0"
-+ "GL_NORMAL_MAP_ARB\0"
-+ "GL_NORMAL_MAP_NV\0"
-+ "GL_NOTEQUAL\0"
-+ "GL_NO_ERROR\0"
-+ "GL_NUM_COMPRESSED_TEXTURE_FORMATS\0"
-+ "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB\0"
-+ "GL_OBJECT_ACTIVE_ATTRIBUTES_ARB\0"
-+ "GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB\0"
-+ "GL_OBJECT_ACTIVE_UNIFORMS_ARB\0"
-+ "GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB\0"
-+ "GL_OBJECT_ATTACHED_OBJECTS_ARB\0"
-+ "GL_OBJECT_COMPILE_STATUS_ARB\0"
-+ "GL_OBJECT_DELETE_STATUS_ARB\0"
-+ "GL_OBJECT_INFO_LOG_LENGTH_ARB\0"
-+ "GL_OBJECT_LINEAR\0"
-+ "GL_OBJECT_LINK_STATUS_ARB\0"
-+ "GL_OBJECT_PLANE\0"
-+ "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB\0"
-+ "GL_OBJECT_SUBTYPE_ARB\0"
-+ "GL_OBJECT_TYPE_ARB\0"
-+ "GL_OBJECT_VALIDATE_STATUS_ARB\0"
-+ "GL_OCCLUSION_TEST_HP\0"
-+ "GL_OCCLUSION_TEST_RESULT_HP\0"
-+ "GL_ONE\0"
-+ "GL_ONE_MINUS_CONSTANT_ALPHA\0"
-+ "GL_ONE_MINUS_CONSTANT_ALPHA_EXT\0"
-+ "GL_ONE_MINUS_CONSTANT_COLOR\0"
-+ "GL_ONE_MINUS_CONSTANT_COLOR_EXT\0"
-+ "GL_ONE_MINUS_DST_ALPHA\0"
-+ "GL_ONE_MINUS_DST_COLOR\0"
-+ "GL_ONE_MINUS_SRC_ALPHA\0"
-+ "GL_ONE_MINUS_SRC_COLOR\0"
-+ "GL_OPERAND0_ALPHA\0"
-+ "GL_OPERAND0_ALPHA_ARB\0"
-+ "GL_OPERAND0_ALPHA_EXT\0"
-+ "GL_OPERAND0_RGB\0"
-+ "GL_OPERAND0_RGB_ARB\0"
-+ "GL_OPERAND0_RGB_EXT\0"
-+ "GL_OPERAND1_ALPHA\0"
-+ "GL_OPERAND1_ALPHA_ARB\0"
-+ "GL_OPERAND1_ALPHA_EXT\0"
-+ "GL_OPERAND1_RGB\0"
-+ "GL_OPERAND1_RGB_ARB\0"
-+ "GL_OPERAND1_RGB_EXT\0"
-+ "GL_OPERAND2_ALPHA\0"
-+ "GL_OPERAND2_ALPHA_ARB\0"
-+ "GL_OPERAND2_ALPHA_EXT\0"
-+ "GL_OPERAND2_RGB\0"
-+ "GL_OPERAND2_RGB_ARB\0"
-+ "GL_OPERAND2_RGB_EXT\0"
-+ "GL_OPERAND3_ALPHA_NV\0"
-+ "GL_OPERAND3_RGB_NV\0"
-+ "GL_OR\0"
-+ "GL_ORDER\0"
-+ "GL_OR_INVERTED\0"
-+ "GL_OR_REVERSE\0"
-+ "GL_OUT_OF_MEMORY\0"
-+ "GL_PACK_ALIGNMENT\0"
-+ "GL_PACK_IMAGE_HEIGHT\0"
-+ "GL_PACK_INVERT_MESA\0"
-+ "GL_PACK_LSB_FIRST\0"
-+ "GL_PACK_ROW_LENGTH\0"
-+ "GL_PACK_SKIP_IMAGES\0"
-+ "GL_PACK_SKIP_PIXELS\0"
-+ "GL_PACK_SKIP_ROWS\0"
-+ "GL_PACK_SWAP_BYTES\0"
-+ "GL_PALETTE4_R5_G6_B5_OES\0"
-+ "GL_PALETTE4_RGB5_A1_OES\0"
-+ "GL_PALETTE4_RGB8_OES\0"
-+ "GL_PALETTE4_RGBA4_OES\0"
-+ "GL_PALETTE4_RGBA8_OES\0"
-+ "GL_PALETTE8_R5_G6_B5_OES\0"
-+ "GL_PALETTE8_RGB5_A1_OES\0"
-+ "GL_PALETTE8_RGB8_OES\0"
-+ "GL_PALETTE8_RGBA4_OES\0"
-+ "GL_PALETTE8_RGBA8_OES\0"
-+ "GL_PASS_THROUGH_TOKEN\0"
-+ "GL_PERSPECTIVE_CORRECTION_HINT\0"
-+ "GL_PIXEL_MAP_A_TO_A\0"
-+ "GL_PIXEL_MAP_A_TO_A_SIZE\0"
-+ "GL_PIXEL_MAP_B_TO_B\0"
-+ "GL_PIXEL_MAP_B_TO_B_SIZE\0"
-+ "GL_PIXEL_MAP_G_TO_G\0"
-+ "GL_PIXEL_MAP_G_TO_G_SIZE\0"
-+ "GL_PIXEL_MAP_I_TO_A\0"
-+ "GL_PIXEL_MAP_I_TO_A_SIZE\0"
-+ "GL_PIXEL_MAP_I_TO_B\0"
-+ "GL_PIXEL_MAP_I_TO_B_SIZE\0"
-+ "GL_PIXEL_MAP_I_TO_G\0"
-+ "GL_PIXEL_MAP_I_TO_G_SIZE\0"
-+ "GL_PIXEL_MAP_I_TO_I\0"
-+ "GL_PIXEL_MAP_I_TO_I_SIZE\0"
-+ "GL_PIXEL_MAP_I_TO_R\0"
-+ "GL_PIXEL_MAP_I_TO_R_SIZE\0"
-+ "GL_PIXEL_MAP_R_TO_R\0"
-+ "GL_PIXEL_MAP_R_TO_R_SIZE\0"
-+ "GL_PIXEL_MAP_S_TO_S\0"
-+ "GL_PIXEL_MAP_S_TO_S_SIZE\0"
-+ "GL_PIXEL_MODE_BIT\0"
-+ "GL_PIXEL_PACK_BUFFER_BINDING_EXT\0"
-+ "GL_PIXEL_PACK_BUFFER_EXT\0"
-+ "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT\0"
-+ "GL_PIXEL_UNPACK_BUFFER_EXT\0"
-+ "GL_POINT\0"
-+ "GL_POINTS\0"
-+ "GL_POINT_BIT\0"
-+ "GL_POINT_DISTANCE_ATTENUATION\0"
-+ "GL_POINT_DISTANCE_ATTENUATION_ARB\0"
-+ "GL_POINT_DISTANCE_ATTENUATION_EXT\0"
-+ "GL_POINT_DISTANCE_ATTENUATION_SGIS\0"
-+ "GL_POINT_FADE_THRESHOLD_SIZE\0"
-+ "GL_POINT_FADE_THRESHOLD_SIZE_ARB\0"
-+ "GL_POINT_FADE_THRESHOLD_SIZE_EXT\0"
-+ "GL_POINT_FADE_THRESHOLD_SIZE_SGIS\0"
-+ "GL_POINT_SIZE\0"
-+ "GL_POINT_SIZE_GRANULARITY\0"
-+ "GL_POINT_SIZE_MAX\0"
-+ "GL_POINT_SIZE_MAX_ARB\0"
-+ "GL_POINT_SIZE_MAX_EXT\0"
-+ "GL_POINT_SIZE_MAX_SGIS\0"
-+ "GL_POINT_SIZE_MIN\0"
-+ "GL_POINT_SIZE_MIN_ARB\0"
-+ "GL_POINT_SIZE_MIN_EXT\0"
-+ "GL_POINT_SIZE_MIN_SGIS\0"
-+ "GL_POINT_SIZE_RANGE\0"
-+ "GL_POINT_SMOOTH\0"
-+ "GL_POINT_SMOOTH_HINT\0"
-+ "GL_POINT_SPRITE\0"
-+ "GL_POINT_SPRITE_ARB\0"
-+ "GL_POINT_SPRITE_COORD_ORIGIN\0"
-+ "GL_POINT_SPRITE_NV\0"
-+ "GL_POINT_SPRITE_R_MODE_NV\0"
-+ "GL_POINT_TOKEN\0"
-+ "GL_POLYGON\0"
-+ "GL_POLYGON_BIT\0"
-+ "GL_POLYGON_MODE\0"
-+ "GL_POLYGON_OFFSET_BIAS\0"
-+ "GL_POLYGON_OFFSET_FACTOR\0"
-+ "GL_POLYGON_OFFSET_FILL\0"
-+ "GL_POLYGON_OFFSET_LINE\0"
-+ "GL_POLYGON_OFFSET_POINT\0"
-+ "GL_POLYGON_OFFSET_UNITS\0"
-+ "GL_POLYGON_SMOOTH\0"
-+ "GL_POLYGON_SMOOTH_HINT\0"
-+ "GL_POLYGON_STIPPLE\0"
-+ "GL_POLYGON_STIPPLE_BIT\0"
-+ "GL_POLYGON_TOKEN\0"
-+ "GL_POSITION\0"
-+ "GL_POST_COLOR_MATRIX_ALPHA_BIAS\0"
-+ "GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI\0"
-+ "GL_POST_COLOR_MATRIX_ALPHA_SCALE\0"
-+ "GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI\0"
-+ "GL_POST_COLOR_MATRIX_BLUE_BIAS\0"
-+ "GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI\0"
-+ "GL_POST_COLOR_MATRIX_BLUE_SCALE\0"
-+ "GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI\0"
-+ "GL_POST_COLOR_MATRIX_COLOR_TABLE\0"
-+ "GL_POST_COLOR_MATRIX_GREEN_BIAS\0"
-+ "GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI\0"
-+ "GL_POST_COLOR_MATRIX_GREEN_SCALE\0"
-+ "GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI\0"
-+ "GL_POST_COLOR_MATRIX_RED_BIAS\0"
-+ "GL_POST_COLOR_MATRIX_RED_BIAS_SGI\0"
-+ "GL_POST_COLOR_MATRIX_RED_SCALE\0"
-+ "GL_POST_COLOR_MATRIX_RED_SCALE_SGI\0"
-+ "GL_POST_CONVOLUTION_ALPHA_BIAS\0"
-+ "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT\0"
-+ "GL_POST_CONVOLUTION_ALPHA_SCALE\0"
-+ "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT\0"
-+ "GL_POST_CONVOLUTION_BLUE_BIAS\0"
-+ "GL_POST_CONVOLUTION_BLUE_BIAS_EXT\0"
-+ "GL_POST_CONVOLUTION_BLUE_SCALE\0"
-+ "GL_POST_CONVOLUTION_BLUE_SCALE_EXT\0"
-+ "GL_POST_CONVOLUTION_COLOR_TABLE\0"
-+ "GL_POST_CONVOLUTION_GREEN_BIAS\0"
-+ "GL_POST_CONVOLUTION_GREEN_BIAS_EXT\0"
-+ "GL_POST_CONVOLUTION_GREEN_SCALE\0"
-+ "GL_POST_CONVOLUTION_GREEN_SCALE_EXT\0"
-+ "GL_POST_CONVOLUTION_RED_BIAS\0"
-+ "GL_POST_CONVOLUTION_RED_BIAS_EXT\0"
-+ "GL_POST_CONVOLUTION_RED_SCALE\0"
-+ "GL_POST_CONVOLUTION_RED_SCALE_EXT\0"
-+ "GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX\0"
-+ "GL_POST_TEXTURE_FILTER_BIAS_SGIX\0"
-+ "GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX\0"
-+ "GL_POST_TEXTURE_FILTER_SCALE_SGIX\0"
-+ "GL_PREVIOUS\0"
-+ "GL_PREVIOUS_ARB\0"
-+ "GL_PREVIOUS_EXT\0"
-+ "GL_PRIMARY_COLOR\0"
-+ "GL_PRIMARY_COLOR_ARB\0"
-+ "GL_PRIMARY_COLOR_EXT\0"
-+ "GL_PROGRAM_ADDRESS_REGISTERS_ARB\0"
-+ "GL_PROGRAM_ALU_INSTRUCTIONS_ARB\0"
-+ "GL_PROGRAM_ATTRIBS_ARB\0"
-+ "GL_PROGRAM_BINDING_ARB\0"
-+ "GL_PROGRAM_ERROR_POSITION_ARB\0"
-+ "GL_PROGRAM_ERROR_POSITION_NV\0"
-+ "GL_PROGRAM_ERROR_STRING_ARB\0"
-+ "GL_PROGRAM_FORMAT_ARB\0"
-+ "GL_PROGRAM_FORMAT_ASCII_ARB\0"
-+ "GL_PROGRAM_INSTRUCTIONS_ARB\0"
-+ "GL_PROGRAM_LENGTH_ARB\0"
-+ "GL_PROGRAM_LENGTH_NV\0"
-+ "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB\0"
-+ "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB\0"
-+ "GL_PROGRAM_NATIVE_ATTRIBS_ARB\0"
-+ "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB\0"
-+ "GL_PROGRAM_NATIVE_PARAMETERS_ARB\0"
-+ "GL_PROGRAM_NATIVE_TEMPORARIES_ARB\0"
-+ "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB\0"
-+ "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB\0"
-+ "GL_PROGRAM_OBJECT_ARB\0"
-+ "GL_PROGRAM_PARAMETERS_ARB\0"
-+ "GL_PROGRAM_PARAMETER_NV\0"
-+ "GL_PROGRAM_RESIDENT_NV\0"
-+ "GL_PROGRAM_STRING_ARB\0"
-+ "GL_PROGRAM_STRING_NV\0"
-+ "GL_PROGRAM_TARGET_NV\0"
-+ "GL_PROGRAM_TEMPORARIES_ARB\0"
-+ "GL_PROGRAM_TEX_INDIRECTIONS_ARB\0"
-+ "GL_PROGRAM_TEX_INSTRUCTIONS_ARB\0"
-+ "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB\0"
-+ "GL_PROJECTION\0"
-+ "GL_PROJECTION_MATRIX\0"
-+ "GL_PROJECTION_STACK_DEPTH\0"
-+ "GL_PROXY_COLOR_TABLE\0"
-+ "GL_PROXY_HISTOGRAM\0"
-+ "GL_PROXY_HISTOGRAM_EXT\0"
-+ "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE\0"
-+ "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE\0"
-+ "GL_PROXY_TEXTURE_1D\0"
-+ "GL_PROXY_TEXTURE_1D_ARRAY_EXT\0"
-+ "GL_PROXY_TEXTURE_1D_EXT\0"
-+ "GL_PROXY_TEXTURE_2D\0"
-+ "GL_PROXY_TEXTURE_2D_ARRAY_EXT\0"
-+ "GL_PROXY_TEXTURE_2D_EXT\0"
-+ "GL_PROXY_TEXTURE_3D\0"
-+ "GL_PROXY_TEXTURE_COLOR_TABLE_SGI\0"
-+ "GL_PROXY_TEXTURE_CUBE_MAP\0"
-+ "GL_PROXY_TEXTURE_CUBE_MAP_ARB\0"
-+ "GL_PROXY_TEXTURE_RECTANGLE_ARB\0"
-+ "GL_PROXY_TEXTURE_RECTANGLE_NV\0"
-+ "GL_Q\0"
-+ "GL_QUADRATIC_ATTENUATION\0"
-+ "GL_QUADS\0"
-+ "GL_QUAD_MESH_SUN\0"
-+ "GL_QUAD_STRIP\0"
-+ "GL_QUERY_COUNTER_BITS\0"
-+ "GL_QUERY_COUNTER_BITS_ARB\0"
-+ "GL_QUERY_RESULT\0"
-+ "GL_QUERY_RESULT_ARB\0"
-+ "GL_QUERY_RESULT_AVAILABLE\0"
-+ "GL_QUERY_RESULT_AVAILABLE_ARB\0"
-+ "GL_R\0"
-+ "GL_R3_G3_B2\0"
-+ "GL_RASTER_POSITION_UNCLIPPED_IBM\0"
-+ "GL_READ_BUFFER\0"
-+ "GL_READ_FRAMEBUFFER_BINDING_EXT\0"
-+ "GL_READ_FRAMEBUFFER_EXT\0"
-+ "GL_READ_ONLY\0"
-+ "GL_READ_ONLY_ARB\0"
-+ "GL_READ_WRITE\0"
-+ "GL_READ_WRITE_ARB\0"
-+ "GL_RED\0"
-+ "GL_REDUCE\0"
-+ "GL_REDUCE_EXT\0"
-+ "GL_RED_BIAS\0"
-+ "GL_RED_BITS\0"
-+ "GL_RED_SCALE\0"
-+ "GL_REFLECTION_MAP\0"
-+ "GL_REFLECTION_MAP_ARB\0"
-+ "GL_REFLECTION_MAP_NV\0"
-+ "GL_RENDER\0"
-+ "GL_RENDERBUFFER_BINDING_EXT\0"
-+ "GL_RENDERBUFFER_EXT\0"
-+ "GL_RENDERBUFFER_HEIGHT_EXT\0"
-+ "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT\0"
-+ "GL_RENDERBUFFER_WIDTH_EXT\0"
-+ "GL_RENDERER\0"
-+ "GL_RENDER_MODE\0"
-+ "GL_REPEAT\0"
-+ "GL_REPLACE\0"
-+ "GL_REPLACE_EXT\0"
-+ "GL_REPLICATE_BORDER_HP\0"
-+ "GL_RESCALE_NORMAL\0"
-+ "GL_RESCALE_NORMAL_EXT\0"
-+ "GL_RETURN\0"
-+ "GL_RGB\0"
-+ "GL_RGB10\0"
-+ "GL_RGB10_A2\0"
-+ "GL_RGB10_A2_EXT\0"
-+ "GL_RGB10_EXT\0"
-+ "GL_RGB12\0"
-+ "GL_RGB12_EXT\0"
-+ "GL_RGB16\0"
-+ "GL_RGB16_EXT\0"
-+ "GL_RGB2_EXT\0"
-+ "GL_RGB4\0"
-+ "GL_RGB4_EXT\0"
-+ "GL_RGB4_S3TC\0"
-+ "GL_RGB5\0"
-+ "GL_RGB5_A1\0"
-+ "GL_RGB5_A1_EXT\0"
-+ "GL_RGB5_EXT\0"
-+ "GL_RGB8\0"
-+ "GL_RGB8_EXT\0"
-+ "GL_RGBA\0"
-+ "GL_RGBA12\0"
-+ "GL_RGBA12_EXT\0"
-+ "GL_RGBA16\0"
-+ "GL_RGBA16_EXT\0"
-+ "GL_RGBA2\0"
-+ "GL_RGBA2_EXT\0"
-+ "GL_RGBA4\0"
-+ "GL_RGBA4_DXT5_S3TC\0"
-+ "GL_RGBA4_EXT\0"
-+ "GL_RGBA4_S3TC\0"
-+ "GL_RGBA8\0"
-+ "GL_RGBA8_EXT\0"
-+ "GL_RGBA_DXT5_S3TC\0"
-+ "GL_RGBA_MODE\0"
-+ "GL_RGBA_S3TC\0"
-+ "GL_RGB_S3TC\0"
-+ "GL_RGB_SCALE\0"
-+ "GL_RGB_SCALE_ARB\0"
-+ "GL_RGB_SCALE_EXT\0"
-+ "GL_RIGHT\0"
-+ "GL_S\0"
-+ "GL_SAMPLER_1D\0"
-+ "GL_SAMPLER_1D_SHADOW\0"
-+ "GL_SAMPLER_2D\0"
-+ "GL_SAMPLER_2D_SHADOW\0"
-+ "GL_SAMPLER_3D\0"
-+ "GL_SAMPLER_CUBE\0"
-+ "GL_SAMPLES\0"
-+ "GL_SAMPLES_3DFX\0"
-+ "GL_SAMPLES_ARB\0"
-+ "GL_SAMPLES_PASSED\0"
-+ "GL_SAMPLES_PASSED_ARB\0"
-+ "GL_SAMPLE_ALPHA_TO_COVERAGE\0"
-+ "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB\0"
-+ "GL_SAMPLE_ALPHA_TO_ONE\0"
-+ "GL_SAMPLE_ALPHA_TO_ONE_ARB\0"
-+ "GL_SAMPLE_BUFFERS\0"
-+ "GL_SAMPLE_BUFFERS_3DFX\0"
-+ "GL_SAMPLE_BUFFERS_ARB\0"
-+ "GL_SAMPLE_COVERAGE\0"
-+ "GL_SAMPLE_COVERAGE_ARB\0"
-+ "GL_SAMPLE_COVERAGE_INVERT\0"
-+ "GL_SAMPLE_COVERAGE_INVERT_ARB\0"
-+ "GL_SAMPLE_COVERAGE_VALUE\0"
-+ "GL_SAMPLE_COVERAGE_VALUE_ARB\0"
-+ "GL_SCISSOR_BIT\0"
-+ "GL_SCISSOR_BOX\0"
-+ "GL_SCISSOR_TEST\0"
-+ "GL_SECONDARY_COLOR_ARRAY\0"
-+ "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING\0"
-+ "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_SECONDARY_COLOR_ARRAY_POINTER\0"
-+ "GL_SECONDARY_COLOR_ARRAY_SIZE\0"
-+ "GL_SECONDARY_COLOR_ARRAY_STRIDE\0"
-+ "GL_SECONDARY_COLOR_ARRAY_TYPE\0"
-+ "GL_SELECT\0"
-+ "GL_SELECTION_BUFFER_POINTER\0"
-+ "GL_SELECTION_BUFFER_SIZE\0"
-+ "GL_SEPARABLE_2D\0"
-+ "GL_SEPARATE_SPECULAR_COLOR\0"
-+ "GL_SEPARATE_SPECULAR_COLOR_EXT\0"
-+ "GL_SET\0"
-+ "GL_SHADER_OBJECT_ARB\0"
-+ "GL_SHADER_SOURCE_LENGTH\0"
-+ "GL_SHADER_TYPE\0"
-+ "GL_SHADE_MODEL\0"
-+ "GL_SHADING_LANGUAGE_VERSION\0"
-+ "GL_SHADOW_AMBIENT_SGIX\0"
-+ "GL_SHARED_TEXTURE_PALETTE_EXT\0"
-+ "GL_SHININESS\0"
-+ "GL_SHORT\0"
-+ "GL_SINGLE_COLOR\0"
-+ "GL_SINGLE_COLOR_EXT\0"
-+ "GL_SLICE_ACCUM_SUN\0"
-+ "GL_SMOOTH\0"
-+ "GL_SMOOTH_LINE_WIDTH_GRANULARITY\0"
-+ "GL_SMOOTH_LINE_WIDTH_RANGE\0"
-+ "GL_SMOOTH_POINT_SIZE_GRANULARITY\0"
-+ "GL_SMOOTH_POINT_SIZE_RANGE\0"
-+ "GL_SOURCE0_ALPHA\0"
-+ "GL_SOURCE0_ALPHA_ARB\0"
-+ "GL_SOURCE0_ALPHA_EXT\0"
-+ "GL_SOURCE0_RGB\0"
-+ "GL_SOURCE0_RGB_ARB\0"
-+ "GL_SOURCE0_RGB_EXT\0"
-+ "GL_SOURCE1_ALPHA\0"
-+ "GL_SOURCE1_ALPHA_ARB\0"
-+ "GL_SOURCE1_ALPHA_EXT\0"
-+ "GL_SOURCE1_RGB\0"
-+ "GL_SOURCE1_RGB_ARB\0"
-+ "GL_SOURCE1_RGB_EXT\0"
-+ "GL_SOURCE2_ALPHA\0"
-+ "GL_SOURCE2_ALPHA_ARB\0"
-+ "GL_SOURCE2_ALPHA_EXT\0"
-+ "GL_SOURCE2_RGB\0"
-+ "GL_SOURCE2_RGB_ARB\0"
-+ "GL_SOURCE2_RGB_EXT\0"
-+ "GL_SOURCE3_ALPHA_NV\0"
-+ "GL_SOURCE3_RGB_NV\0"
-+ "GL_SPECULAR\0"
-+ "GL_SPHERE_MAP\0"
-+ "GL_SPOT_CUTOFF\0"
-+ "GL_SPOT_DIRECTION\0"
-+ "GL_SPOT_EXPONENT\0"
-+ "GL_SRC0_ALPHA\0"
-+ "GL_SRC0_RGB\0"
-+ "GL_SRC1_ALPHA\0"
-+ "GL_SRC1_RGB\0"
-+ "GL_SRC2_ALPHA\0"
-+ "GL_SRC2_RGB\0"
-+ "GL_SRC_ALPHA\0"
-+ "GL_SRC_ALPHA_SATURATE\0"
-+ "GL_SRC_COLOR\0"
-+ "GL_STACK_OVERFLOW\0"
-+ "GL_STACK_UNDERFLOW\0"
-+ "GL_STATIC_COPY\0"
-+ "GL_STATIC_COPY_ARB\0"
-+ "GL_STATIC_DRAW\0"
-+ "GL_STATIC_DRAW_ARB\0"
-+ "GL_STATIC_READ\0"
-+ "GL_STATIC_READ_ARB\0"
-+ "GL_STENCIL\0"
-+ "GL_STENCIL_ATTACHMENT_EXT\0"
-+ "GL_STENCIL_BACK_FAIL\0"
-+ "GL_STENCIL_BACK_FUNC\0"
-+ "GL_STENCIL_BACK_PASS_DEPTH_FAIL\0"
-+ "GL_STENCIL_BACK_PASS_DEPTH_PASS\0"
-+ "GL_STENCIL_BACK_REF\0"
-+ "GL_STENCIL_BACK_VALUE_MASK\0"
-+ "GL_STENCIL_BACK_WRITEMASK\0"
-+ "GL_STENCIL_BITS\0"
-+ "GL_STENCIL_BUFFER_BIT\0"
-+ "GL_STENCIL_CLEAR_VALUE\0"
-+ "GL_STENCIL_FAIL\0"
-+ "GL_STENCIL_FUNC\0"
-+ "GL_STENCIL_INDEX\0"
-+ "GL_STENCIL_INDEX16_EXT\0"
-+ "GL_STENCIL_INDEX1_EXT\0"
-+ "GL_STENCIL_INDEX4_EXT\0"
-+ "GL_STENCIL_INDEX8_EXT\0"
-+ "GL_STENCIL_INDEX_EXT\0"
-+ "GL_STENCIL_PASS_DEPTH_FAIL\0"
-+ "GL_STENCIL_PASS_DEPTH_PASS\0"
-+ "GL_STENCIL_REF\0"
-+ "GL_STENCIL_TEST\0"
-+ "GL_STENCIL_TEST_TWO_SIDE_EXT\0"
-+ "GL_STENCIL_VALUE_MASK\0"
-+ "GL_STENCIL_WRITEMASK\0"
-+ "GL_STEREO\0"
-+ "GL_STREAM_COPY\0"
-+ "GL_STREAM_COPY_ARB\0"
-+ "GL_STREAM_DRAW\0"
-+ "GL_STREAM_DRAW_ARB\0"
-+ "GL_STREAM_READ\0"
-+ "GL_STREAM_READ_ARB\0"
-+ "GL_SUBPIXEL_BITS\0"
-+ "GL_SUBTRACT\0"
-+ "GL_SUBTRACT_ARB\0"
-+ "GL_T\0"
-+ "GL_T2F_C3F_V3F\0"
-+ "GL_T2F_C4F_N3F_V3F\0"
-+ "GL_T2F_C4UB_V3F\0"
-+ "GL_T2F_N3F_V3F\0"
-+ "GL_T2F_V3F\0"
-+ "GL_T4F_C4F_N3F_V4F\0"
-+ "GL_T4F_V4F\0"
-+ "GL_TABLE_TOO_LARGE_EXT\0"
-+ "GL_TEXTURE\0"
-+ "GL_TEXTURE0\0"
-+ "GL_TEXTURE0_ARB\0"
-+ "GL_TEXTURE1\0"
-+ "GL_TEXTURE10\0"
-+ "GL_TEXTURE10_ARB\0"
-+ "GL_TEXTURE11\0"
-+ "GL_TEXTURE11_ARB\0"
-+ "GL_TEXTURE12\0"
-+ "GL_TEXTURE12_ARB\0"
-+ "GL_TEXTURE13\0"
-+ "GL_TEXTURE13_ARB\0"
-+ "GL_TEXTURE14\0"
-+ "GL_TEXTURE14_ARB\0"
-+ "GL_TEXTURE15\0"
-+ "GL_TEXTURE15_ARB\0"
-+ "GL_TEXTURE16\0"
-+ "GL_TEXTURE16_ARB\0"
-+ "GL_TEXTURE17\0"
-+ "GL_TEXTURE17_ARB\0"
-+ "GL_TEXTURE18\0"
-+ "GL_TEXTURE18_ARB\0"
-+ "GL_TEXTURE19\0"
-+ "GL_TEXTURE19_ARB\0"
-+ "GL_TEXTURE1_ARB\0"
-+ "GL_TEXTURE2\0"
-+ "GL_TEXTURE20\0"
-+ "GL_TEXTURE20_ARB\0"
-+ "GL_TEXTURE21\0"
-+ "GL_TEXTURE21_ARB\0"
-+ "GL_TEXTURE22\0"
-+ "GL_TEXTURE22_ARB\0"
-+ "GL_TEXTURE23\0"
-+ "GL_TEXTURE23_ARB\0"
-+ "GL_TEXTURE24\0"
-+ "GL_TEXTURE24_ARB\0"
-+ "GL_TEXTURE25\0"
-+ "GL_TEXTURE25_ARB\0"
-+ "GL_TEXTURE26\0"
-+ "GL_TEXTURE26_ARB\0"
-+ "GL_TEXTURE27\0"
-+ "GL_TEXTURE27_ARB\0"
-+ "GL_TEXTURE28\0"
-+ "GL_TEXTURE28_ARB\0"
-+ "GL_TEXTURE29\0"
-+ "GL_TEXTURE29_ARB\0"
-+ "GL_TEXTURE2_ARB\0"
-+ "GL_TEXTURE3\0"
-+ "GL_TEXTURE30\0"
-+ "GL_TEXTURE30_ARB\0"
-+ "GL_TEXTURE31\0"
-+ "GL_TEXTURE31_ARB\0"
-+ "GL_TEXTURE3_ARB\0"
-+ "GL_TEXTURE4\0"
-+ "GL_TEXTURE4_ARB\0"
-+ "GL_TEXTURE5\0"
-+ "GL_TEXTURE5_ARB\0"
-+ "GL_TEXTURE6\0"
-+ "GL_TEXTURE6_ARB\0"
-+ "GL_TEXTURE7\0"
-+ "GL_TEXTURE7_ARB\0"
-+ "GL_TEXTURE8\0"
-+ "GL_TEXTURE8_ARB\0"
-+ "GL_TEXTURE9\0"
-+ "GL_TEXTURE9_ARB\0"
-+ "GL_TEXTURE_1D\0"
-+ "GL_TEXTURE_1D_ARRAY_EXT\0"
-+ "GL_TEXTURE_2D\0"
-+ "GL_TEXTURE_2D_ARRAY_EXT\0"
-+ "GL_TEXTURE_3D\0"
-+ "GL_TEXTURE_ALPHA_SIZE\0"
-+ "GL_TEXTURE_ALPHA_SIZE_EXT\0"
-+ "GL_TEXTURE_BASE_LEVEL\0"
-+ "GL_TEXTURE_BINDING_1D\0"
-+ "GL_TEXTURE_BINDING_1D_ARRAY_EXT\0"
-+ "GL_TEXTURE_BINDING_2D\0"
-+ "GL_TEXTURE_BINDING_2D_ARRAY_EXT\0"
-+ "GL_TEXTURE_BINDING_3D\0"
-+ "GL_TEXTURE_BINDING_CUBE_MAP\0"
-+ "GL_TEXTURE_BINDING_CUBE_MAP_ARB\0"
-+ "GL_TEXTURE_BINDING_RECTANGLE_ARB\0"
-+ "GL_TEXTURE_BINDING_RECTANGLE_NV\0"
-+ "GL_TEXTURE_BIT\0"
-+ "GL_TEXTURE_BLUE_SIZE\0"
-+ "GL_TEXTURE_BLUE_SIZE_EXT\0"
-+ "GL_TEXTURE_BORDER\0"
-+ "GL_TEXTURE_BORDER_COLOR\0"
-+ "GL_TEXTURE_CLIPMAP_CENTER_SGIX\0"
-+ "GL_TEXTURE_CLIPMAP_DEPTH_SGIX\0"
-+ "GL_TEXTURE_CLIPMAP_FRAME_SGIX\0"
-+ "GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX\0"
-+ "GL_TEXTURE_CLIPMAP_OFFSET_SGIX\0"
-+ "GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX\0"
-+ "GL_TEXTURE_COLOR_TABLE_SGI\0"
-+ "GL_TEXTURE_COLOR_WRITEMASK_SGIS\0"
-+ "GL_TEXTURE_COMPARE_FAIL_VALUE_ARB\0"
-+ "GL_TEXTURE_COMPARE_FUNC\0"
-+ "GL_TEXTURE_COMPARE_FUNC_ARB\0"
-+ "GL_TEXTURE_COMPARE_MODE\0"
-+ "GL_TEXTURE_COMPARE_MODE_ARB\0"
-+ "GL_TEXTURE_COMPARE_OPERATOR_SGIX\0"
-+ "GL_TEXTURE_COMPARE_SGIX\0"
-+ "GL_TEXTURE_COMPONENTS\0"
-+ "GL_TEXTURE_COMPRESSED\0"
-+ "GL_TEXTURE_COMPRESSED_ARB\0"
-+ "GL_TEXTURE_COMPRESSED_FORMATS_ARB\0"
-+ "GL_TEXTURE_COMPRESSED_IMAGE_SIZE\0"
-+ "GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB\0"
-+ "GL_TEXTURE_COMPRESSION_HINT\0"
-+ "GL_TEXTURE_COMPRESSION_HINT_ARB\0"
-+ "GL_TEXTURE_COORD_ARRAY\0"
-+ "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING\0"
-+ "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_TEXTURE_COORD_ARRAY_POINTER\0"
-+ "GL_TEXTURE_COORD_ARRAY_SIZE\0"
-+ "GL_TEXTURE_COORD_ARRAY_STRIDE\0"
-+ "GL_TEXTURE_COORD_ARRAY_TYPE\0"
-+ "GL_TEXTURE_CUBE_MAP\0"
-+ "GL_TEXTURE_CUBE_MAP_ARB\0"
-+ "GL_TEXTURE_CUBE_MAP_NEGATIVE_X\0"
-+ "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB\0"
-+ "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y\0"
-+ "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB\0"
-+ "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z\0"
-+ "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB\0"
-+ "GL_TEXTURE_CUBE_MAP_POSITIVE_X\0"
-+ "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB\0"
-+ "GL_TEXTURE_CUBE_MAP_POSITIVE_Y\0"
-+ "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\0"
-+ "GL_TEXTURE_CUBE_MAP_POSITIVE_Z\0"
-+ "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\0"
-+ "GL_TEXTURE_DEPTH\0"
-+ "GL_TEXTURE_DEPTH_SIZE\0"
-+ "GL_TEXTURE_DEPTH_SIZE_ARB\0"
-+ "GL_TEXTURE_ENV\0"
-+ "GL_TEXTURE_ENV_COLOR\0"
-+ "GL_TEXTURE_ENV_MODE\0"
-+ "GL_TEXTURE_FILTER_CONTROL\0"
-+ "GL_TEXTURE_GEN_MODE\0"
-+ "GL_TEXTURE_GEN_Q\0"
-+ "GL_TEXTURE_GEN_R\0"
-+ "GL_TEXTURE_GEN_S\0"
-+ "GL_TEXTURE_GEN_T\0"
-+ "GL_TEXTURE_GEQUAL_R_SGIX\0"
-+ "GL_TEXTURE_GREEN_SIZE\0"
-+ "GL_TEXTURE_GREEN_SIZE_EXT\0"
-+ "GL_TEXTURE_HEIGHT\0"
-+ "GL_TEXTURE_INDEX_SIZE_EXT\0"
-+ "GL_TEXTURE_INTENSITY_SIZE\0"
-+ "GL_TEXTURE_INTENSITY_SIZE_EXT\0"
-+ "GL_TEXTURE_INTERNAL_FORMAT\0"
-+ "GL_TEXTURE_LEQUAL_R_SGIX\0"
-+ "GL_TEXTURE_LOD_BIAS\0"
-+ "GL_TEXTURE_LOD_BIAS_EXT\0"
-+ "GL_TEXTURE_LOD_BIAS_R_SGIX\0"
-+ "GL_TEXTURE_LOD_BIAS_S_SGIX\0"
-+ "GL_TEXTURE_LOD_BIAS_T_SGIX\0"
-+ "GL_TEXTURE_LUMINANCE_SIZE\0"
-+ "GL_TEXTURE_LUMINANCE_SIZE_EXT\0"
-+ "GL_TEXTURE_MAG_FILTER\0"
-+ "GL_TEXTURE_MATRIX\0"
-+ "GL_TEXTURE_MAX_ANISOTROPY_EXT\0"
-+ "GL_TEXTURE_MAX_CLAMP_R_SGIX\0"
-+ "GL_TEXTURE_MAX_CLAMP_S_SGIX\0"
-+ "GL_TEXTURE_MAX_CLAMP_T_SGIX\0"
-+ "GL_TEXTURE_MAX_LEVEL\0"
-+ "GL_TEXTURE_MAX_LOD\0"
-+ "GL_TEXTURE_MIN_FILTER\0"
-+ "GL_TEXTURE_MIN_LOD\0"
-+ "GL_TEXTURE_PRIORITY\0"
-+ "GL_TEXTURE_RECTANGLE_ARB\0"
-+ "GL_TEXTURE_RECTANGLE_NV\0"
-+ "GL_TEXTURE_RED_SIZE\0"
-+ "GL_TEXTURE_RED_SIZE_EXT\0"
-+ "GL_TEXTURE_RESIDENT\0"
-+ "GL_TEXTURE_STACK_DEPTH\0"
-+ "GL_TEXTURE_TOO_LARGE_EXT\0"
-+ "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV\0"
-+ "GL_TEXTURE_WIDTH\0"
-+ "GL_TEXTURE_WRAP_R\0"
-+ "GL_TEXTURE_WRAP_S\0"
-+ "GL_TEXTURE_WRAP_T\0"
-+ "GL_TIME_ELAPSED_EXT\0"
-+ "GL_TRACK_MATRIX_NV\0"
-+ "GL_TRACK_MATRIX_TRANSFORM_NV\0"
-+ "GL_TRANSFORM_BIT\0"
-+ "GL_TRANSPOSE_COLOR_MATRIX\0"
-+ "GL_TRANSPOSE_COLOR_MATRIX_ARB\0"
-+ "GL_TRANSPOSE_CURRENT_MATRIX_ARB\0"
-+ "GL_TRANSPOSE_MODELVIEW_MATRIX\0"
-+ "GL_TRANSPOSE_MODELVIEW_MATRIX_ARB\0"
-+ "GL_TRANSPOSE_NV\0"
-+ "GL_TRANSPOSE_PROJECTION_MATRIX\0"
-+ "GL_TRANSPOSE_PROJECTION_MATRIX_ARB\0"
-+ "GL_TRANSPOSE_TEXTURE_MATRIX\0"
-+ "GL_TRANSPOSE_TEXTURE_MATRIX_ARB\0"
-+ "GL_TRIANGLES\0"
-+ "GL_TRIANGLE_FAN\0"
-+ "GL_TRIANGLE_MESH_SUN\0"
-+ "GL_TRIANGLE_STRIP\0"
-+ "GL_TRUE\0"
-+ "GL_UNPACK_ALIGNMENT\0"
-+ "GL_UNPACK_IMAGE_HEIGHT\0"
-+ "GL_UNPACK_LSB_FIRST\0"
-+ "GL_UNPACK_ROW_LENGTH\0"
-+ "GL_UNPACK_SKIP_IMAGES\0"
-+ "GL_UNPACK_SKIP_PIXELS\0"
-+ "GL_UNPACK_SKIP_ROWS\0"
-+ "GL_UNPACK_SWAP_BYTES\0"
-+ "GL_UNSIGNED_BYTE\0"
-+ "GL_UNSIGNED_BYTE_2_3_3_REV\0"
-+ "GL_UNSIGNED_BYTE_3_3_2\0"
-+ "GL_UNSIGNED_INT\0"
-+ "GL_UNSIGNED_INT_10_10_10_2\0"
-+ "GL_UNSIGNED_INT_24_8_NV\0"
-+ "GL_UNSIGNED_INT_2_10_10_10_REV\0"
-+ "GL_UNSIGNED_INT_8_8_8_8\0"
-+ "GL_UNSIGNED_INT_8_8_8_8_REV\0"
-+ "GL_UNSIGNED_SHORT\0"
-+ "GL_UNSIGNED_SHORT_1_5_5_5_REV\0"
-+ "GL_UNSIGNED_SHORT_4_4_4_4\0"
-+ "GL_UNSIGNED_SHORT_4_4_4_4_REV\0"
-+ "GL_UNSIGNED_SHORT_5_5_5_1\0"
-+ "GL_UNSIGNED_SHORT_5_6_5\0"
-+ "GL_UNSIGNED_SHORT_5_6_5_REV\0"
-+ "GL_UNSIGNED_SHORT_8_8_APPLE\0"
-+ "GL_UNSIGNED_SHORT_8_8_MESA\0"
-+ "GL_UNSIGNED_SHORT_8_8_REV_APPLE\0"
-+ "GL_UNSIGNED_SHORT_8_8_REV_MESA\0"
-+ "GL_UPPER_LEFT\0"
-+ "GL_V2F\0"
-+ "GL_V3F\0"
-+ "GL_VALIDATE_STATUS\0"
-+ "GL_VENDOR\0"
-+ "GL_VERSION\0"
-+ "GL_VERTEX_ARRAY\0"
-+ "GL_VERTEX_ARRAY_BINDING_APPLE\0"
-+ "GL_VERTEX_ARRAY_BUFFER_BINDING\0"
-+ "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_VERTEX_ARRAY_POINTER\0"
-+ "GL_VERTEX_ARRAY_SIZE\0"
-+ "GL_VERTEX_ARRAY_STRIDE\0"
-+ "GL_VERTEX_ARRAY_TYPE\0"
-+ "GL_VERTEX_ATTRIB_ARRAY0_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY10_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY11_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY12_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY13_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY14_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY15_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY1_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY2_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY3_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY4_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY5_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY6_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY7_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY8_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY9_NV\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_ENABLED\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_POINTER\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_SIZE\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_STRIDE\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_TYPE\0"
-+ "GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB\0"
-+ "GL_VERTEX_BLEND_ARB\0"
-+ "GL_VERTEX_PROGRAM_ARB\0"
-+ "GL_VERTEX_PROGRAM_BINDING_NV\0"
-+ "GL_VERTEX_PROGRAM_NV\0"
-+ "GL_VERTEX_PROGRAM_POINT_SIZE\0"
-+ "GL_VERTEX_PROGRAM_POINT_SIZE_ARB\0"
-+ "GL_VERTEX_PROGRAM_POINT_SIZE_NV\0"
-+ "GL_VERTEX_PROGRAM_TWO_SIDE\0"
-+ "GL_VERTEX_PROGRAM_TWO_SIDE_ARB\0"
-+ "GL_VERTEX_PROGRAM_TWO_SIDE_NV\0"
-+ "GL_VERTEX_SHADER\0"
-+ "GL_VERTEX_SHADER_ARB\0"
-+ "GL_VERTEX_STATE_PROGRAM_NV\0"
-+ "GL_VIEWPORT\0"
-+ "GL_VIEWPORT_BIT\0"
-+ "GL_WEIGHT_ARRAY_ARB\0"
-+ "GL_WEIGHT_ARRAY_BUFFER_BINDING\0"
-+ "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB\0"
-+ "GL_WEIGHT_ARRAY_POINTER_ARB\0"
-+ "GL_WEIGHT_ARRAY_SIZE_ARB\0"
-+ "GL_WEIGHT_ARRAY_STRIDE_ARB\0"
-+ "GL_WEIGHT_ARRAY_TYPE_ARB\0"
-+ "GL_WEIGHT_SUM_UNITY_ARB\0"
-+ "GL_WRAP_BORDER_SUN\0"
-+ "GL_WRITE_ONLY\0"
-+ "GL_WRITE_ONLY_ARB\0"
-+ "GL_XOR\0"
-+ "GL_YCBCR_422_APPLE\0"
-+ "GL_YCBCR_MESA\0"
-+ "GL_ZERO\0"
-+ "GL_ZOOM_X\0"
-+ "GL_ZOOM_Y\0"
-+ ;
-+
-+static const enum_elt all_enums[1746] =
-+{
-+ { 0, 0x00000600 }, /* GL_2D */
-+ { 6, 0x00001407 }, /* GL_2_BYTES */
-+ { 17, 0x00000601 }, /* GL_3D */
-+ { 23, 0x00000602 }, /* GL_3D_COLOR */
-+ { 35, 0x00000603 }, /* GL_3D_COLOR_TEXTURE */
-+ { 55, 0x00001408 }, /* GL_3_BYTES */
-+ { 66, 0x00000604 }, /* GL_4D_COLOR_TEXTURE */
-+ { 86, 0x00001409 }, /* GL_4_BYTES */
-+ { 97, 0x00000100 }, /* GL_ACCUM */
-+ { 106, 0x00000D5B }, /* GL_ACCUM_ALPHA_BITS */
-+ { 126, 0x00000D5A }, /* GL_ACCUM_BLUE_BITS */
-+ { 145, 0x00000200 }, /* GL_ACCUM_BUFFER_BIT */
-+ { 165, 0x00000B80 }, /* GL_ACCUM_CLEAR_VALUE */
-+ { 186, 0x00000D59 }, /* GL_ACCUM_GREEN_BITS */
-+ { 206, 0x00000D58 }, /* GL_ACCUM_RED_BITS */
-+ { 224, 0x00008B89 }, /* GL_ACTIVE_ATTRIBUTES */
-+ { 245, 0x00008B8A }, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
-+ { 276, 0x00008911 }, /* GL_ACTIVE_STENCIL_FACE_EXT */
-+ { 303, 0x000084E0 }, /* GL_ACTIVE_TEXTURE */
-+ { 321, 0x000084E0 }, /* GL_ACTIVE_TEXTURE_ARB */
-+ { 343, 0x00008B86 }, /* GL_ACTIVE_UNIFORMS */
-+ { 362, 0x00008B87 }, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-+ { 391, 0x000086A5 }, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-+ { 418, 0x00000104 }, /* GL_ADD */
-+ { 425, 0x00008574 }, /* GL_ADD_SIGNED */
-+ { 439, 0x00008574 }, /* GL_ADD_SIGNED_ARB */
-+ { 457, 0x00008574 }, /* GL_ADD_SIGNED_EXT */
-+ { 475, 0x0000846E }, /* GL_ALIASED_LINE_WIDTH_RANGE */
-+ { 503, 0x0000846D }, /* GL_ALIASED_POINT_SIZE_RANGE */
-+ { 531, 0x000FFFFF }, /* GL_ALL_ATTRIB_BITS */
-+ { 550, 0xFFFFFFFF }, /* GL_ALL_CLIENT_ATTRIB_BITS */
-+ { 576, 0x00001906 }, /* GL_ALPHA */
-+ { 585, 0x0000803D }, /* GL_ALPHA12 */
-+ { 596, 0x0000803D }, /* GL_ALPHA12_EXT */
-+ { 611, 0x0000803E }, /* GL_ALPHA16 */
-+ { 622, 0x0000803E }, /* GL_ALPHA16_EXT */
-+ { 637, 0x0000803B }, /* GL_ALPHA4 */
-+ { 647, 0x0000803B }, /* GL_ALPHA4_EXT */
-+ { 661, 0x0000803C }, /* GL_ALPHA8 */
-+ { 671, 0x0000803C }, /* GL_ALPHA8_EXT */
-+ { 685, 0x00000D1D }, /* GL_ALPHA_BIAS */
-+ { 699, 0x00000D55 }, /* GL_ALPHA_BITS */
-+ { 713, 0x00000D1C }, /* GL_ALPHA_SCALE */
-+ { 728, 0x00000BC0 }, /* GL_ALPHA_TEST */
-+ { 742, 0x00000BC1 }, /* GL_ALPHA_TEST_FUNC */
-+ { 761, 0x00000BC2 }, /* GL_ALPHA_TEST_REF */
-+ { 779, 0x00000207 }, /* GL_ALWAYS */
-+ { 789, 0x00001200 }, /* GL_AMBIENT */
-+ { 800, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */
-+ { 823, 0x00001501 }, /* GL_AND */
-+ { 830, 0x00001504 }, /* GL_AND_INVERTED */
-+ { 846, 0x00001502 }, /* GL_AND_REVERSE */
-+ { 861, 0x00008892 }, /* GL_ARRAY_BUFFER */
-+ { 877, 0x00008892 }, /* GL_ARRAY_BUFFER_ARB */
-+ { 897, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */
-+ { 921, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */
-+ { 949, 0x00008B85 }, /* GL_ATTACHED_SHADERS */
-+ { 969, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */
-+ { 996, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */
-+ { 1020, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */
-+ { 1046, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */
-+ { 1070, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */
-+ { 1092, 0x00000D80 }, /* GL_AUTO_NORMAL */
-+ { 1107, 0x00000409 }, /* GL_AUX0 */
-+ { 1115, 0x0000040A }, /* GL_AUX1 */
-+ { 1123, 0x0000040B }, /* GL_AUX2 */
-+ { 1131, 0x0000040C }, /* GL_AUX3 */
-+ { 1139, 0x00000C00 }, /* GL_AUX_BUFFERS */
-+ { 1154, 0x00000405 }, /* GL_BACK */
-+ { 1162, 0x00000402 }, /* GL_BACK_LEFT */
-+ { 1175, 0x00000403 }, /* GL_BACK_RIGHT */
-+ { 1189, 0x000080E0 }, /* GL_BGR */
-+ { 1196, 0x000080E1 }, /* GL_BGRA */
-+ { 1204, 0x00001A00 }, /* GL_BITMAP */
-+ { 1214, 0x00000704 }, /* GL_BITMAP_TOKEN */
-+ { 1230, 0x00000BE2 }, /* GL_BLEND */
-+ { 1239, 0x00008005 }, /* GL_BLEND_COLOR */
-+ { 1254, 0x00008005 }, /* GL_BLEND_COLOR_EXT */
-+ { 1273, 0x00000BE0 }, /* GL_BLEND_DST */
-+ { 1286, 0x000080CA }, /* GL_BLEND_DST_ALPHA */
-+ { 1305, 0x000080C8 }, /* GL_BLEND_DST_RGB */
-+ { 1322, 0x00008009 }, /* GL_BLEND_EQUATION */
-+ { 1340, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */
-+ { 1364, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */
-+ { 1392, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */
-+ { 1414, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */
-+ { 1440, 0x00000BE1 }, /* GL_BLEND_SRC */
-+ { 1453, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */
-+ { 1472, 0x000080C9 }, /* GL_BLEND_SRC_RGB */
-+ { 1489, 0x00001905 }, /* GL_BLUE */
-+ { 1497, 0x00000D1B }, /* GL_BLUE_BIAS */
-+ { 1510, 0x00000D54 }, /* GL_BLUE_BITS */
-+ { 1523, 0x00000D1A }, /* GL_BLUE_SCALE */
-+ { 1537, 0x00008B56 }, /* GL_BOOL */
-+ { 1545, 0x00008B56 }, /* GL_BOOL_ARB */
-+ { 1557, 0x00008B57 }, /* GL_BOOL_VEC2 */
-+ { 1570, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */
-+ { 1587, 0x00008B58 }, /* GL_BOOL_VEC3 */
-+ { 1600, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */
-+ { 1617, 0x00008B59 }, /* GL_BOOL_VEC4 */
-+ { 1630, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */
-+ { 1647, 0x000088BB }, /* GL_BUFFER_ACCESS */
-+ { 1664, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */
-+ { 1685, 0x000088BC }, /* GL_BUFFER_MAPPED */
-+ { 1702, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */
-+ { 1723, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */
-+ { 1745, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */
-+ { 1771, 0x00008764 }, /* GL_BUFFER_SIZE */
-+ { 1786, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */
-+ { 1805, 0x00008765 }, /* GL_BUFFER_USAGE */
-+ { 1821, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */
-+ { 1841, 0x00001400 }, /* GL_BYTE */
-+ { 1849, 0x00002A24 }, /* GL_C3F_V3F */
-+ { 1860, 0x00002A26 }, /* GL_C4F_N3F_V3F */
-+ { 1875, 0x00002A22 }, /* GL_C4UB_V2F */
-+ { 1887, 0x00002A23 }, /* GL_C4UB_V3F */
-+ { 1899, 0x00000901 }, /* GL_CCW */
-+ { 1906, 0x00002900 }, /* GL_CLAMP */
-+ { 1915, 0x0000812D }, /* GL_CLAMP_TO_BORDER */
-+ { 1934, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */
-+ { 1957, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */
-+ { 1981, 0x0000812F }, /* GL_CLAMP_TO_EDGE */
-+ { 1998, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */
-+ { 2020, 0x00001500 }, /* GL_CLEAR */
-+ { 2029, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */
-+ { 2054, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */
-+ { 2083, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */
-+ { 2109, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
-+ { 2138, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */
-+ { 2164, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */
-+ { 2191, 0x00003000 }, /* GL_CLIP_PLANE0 */
-+ { 2206, 0x00003001 }, /* GL_CLIP_PLANE1 */
-+ { 2221, 0x00003002 }, /* GL_CLIP_PLANE2 */
-+ { 2236, 0x00003003 }, /* GL_CLIP_PLANE3 */
-+ { 2251, 0x00003004 }, /* GL_CLIP_PLANE4 */
-+ { 2266, 0x00003005 }, /* GL_CLIP_PLANE5 */
-+ { 2281, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-+ { 2314, 0x00000A00 }, /* GL_COEFF */
-+ { 2323, 0x00001800 }, /* GL_COLOR */
-+ { 2332, 0x00008076 }, /* GL_COLOR_ARRAY */
-+ { 2347, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-+ { 2377, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */
-+ { 2411, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */
-+ { 2434, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */
-+ { 2454, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */
-+ { 2476, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */
-+ { 2496, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */
-+ { 2521, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */
-+ { 2547, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */
-+ { 2573, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */
-+ { 2599, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */
-+ { 2625, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */
-+ { 2651, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */
-+ { 2677, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */
-+ { 2702, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */
-+ { 2727, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */
-+ { 2752, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */
-+ { 2777, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */
-+ { 2802, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */
-+ { 2827, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */
-+ { 2852, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */
-+ { 2877, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */
-+ { 2902, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */
-+ { 2922, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */
-+ { 2943, 0x00001900 }, /* GL_COLOR_INDEX */
-+ { 2958, 0x00001603 }, /* GL_COLOR_INDEXES */
-+ { 2975, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */
-+ { 2993, 0x00000B57 }, /* GL_COLOR_MATERIAL */
-+ { 3011, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */
-+ { 3034, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */
-+ { 3062, 0x000080B1 }, /* GL_COLOR_MATRIX */
-+ { 3078, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */
-+ { 3098, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */
-+ { 3126, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */
-+ { 3158, 0x00008458 }, /* GL_COLOR_SUM */
-+ { 3171, 0x00008458 }, /* GL_COLOR_SUM_ARB */
-+ { 3188, 0x000080D0 }, /* GL_COLOR_TABLE */
-+ { 3203, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */
-+ { 3229, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */
-+ { 3259, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */
-+ { 3289, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */
-+ { 3309, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */
-+ { 3333, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */
-+ { 3358, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */
-+ { 3387, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */
-+ { 3416, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */
-+ { 3438, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */
-+ { 3464, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */
-+ { 3490, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */
-+ { 3516, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */
-+ { 3546, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */
-+ { 3576, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */
-+ { 3606, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */
-+ { 3640, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */
-+ { 3674, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
-+ { 3704, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */
-+ { 3738, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */
-+ { 3772, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */
-+ { 3796, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */
-+ { 3824, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */
-+ { 3852, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */
-+ { 3873, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */
-+ { 3898, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */
-+ { 3919, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */
-+ { 3944, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */
-+ { 3969, 0x00000C23 }, /* GL_COLOR_WRITEMASK */
-+ { 3988, 0x00008570 }, /* GL_COMBINE */
-+ { 3999, 0x00008503 }, /* GL_COMBINE4 */
-+ { 4011, 0x00008572 }, /* GL_COMBINE_ALPHA */
-+ { 4028, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */
-+ { 4049, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */
-+ { 4070, 0x00008570 }, /* GL_COMBINE_ARB */
-+ { 4085, 0x00008570 }, /* GL_COMBINE_EXT */
-+ { 4100, 0x00008571 }, /* GL_COMBINE_RGB */
-+ { 4115, 0x00008571 }, /* GL_COMBINE_RGB_ARB */
-+ { 4134, 0x00008571 }, /* GL_COMBINE_RGB_EXT */
-+ { 4153, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */
-+ { 4189, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */
-+ { 4213, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */
-+ { 4241, 0x00001300 }, /* GL_COMPILE */
-+ { 4252, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */
-+ { 4275, 0x00008B81 }, /* GL_COMPILE_STATUS */
-+ { 4293, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */
-+ { 4313, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */
-+ { 4337, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */
-+ { 4361, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */
-+ { 4389, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */
-+ { 4413, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */
-+ { 4443, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */
-+ { 4477, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */
-+ { 4505, 0x000084ED }, /* GL_COMPRESSED_RGB */
-+ { 4523, 0x000084EE }, /* GL_COMPRESSED_RGBA */
-+ { 4542, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */
-+ { 4565, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-+ { 4594, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
-+ { 4627, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
-+ { 4660, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-+ { 4693, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */
-+ { 4715, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */
-+ { 4743, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
-+ { 4775, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */
-+ { 4805, 0x00008576 }, /* GL_CONSTANT */
-+ { 4817, 0x00008003 }, /* GL_CONSTANT_ALPHA */
-+ { 4835, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */
-+ { 4857, 0x00008576 }, /* GL_CONSTANT_ARB */
-+ { 4873, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */
-+ { 4897, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */
-+ { 4919, 0x00008001 }, /* GL_CONSTANT_COLOR */
-+ { 4937, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */
-+ { 4959, 0x00008576 }, /* GL_CONSTANT_EXT */
-+ { 4975, 0x00008010 }, /* GL_CONVOLUTION_1D */
-+ { 4993, 0x00008011 }, /* GL_CONVOLUTION_2D */
-+ { 5011, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */
-+ { 5039, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */
-+ { 5070, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */
-+ { 5097, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */
-+ { 5128, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */
-+ { 5155, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */
-+ { 5186, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */
-+ { 5214, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */
-+ { 5246, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */
-+ { 5268, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */
-+ { 5294, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */
-+ { 5316, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */
-+ { 5342, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */
-+ { 5363, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */
-+ { 5388, 0x00008862 }, /* GL_COORD_REPLACE */
-+ { 5405, 0x00008862 }, /* GL_COORD_REPLACE_ARB */
-+ { 5426, 0x00008862 }, /* GL_COORD_REPLACE_NV */
-+ { 5446, 0x00001503 }, /* GL_COPY */
-+ { 5454, 0x0000150C }, /* GL_COPY_INVERTED */
-+ { 5471, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */
-+ { 5491, 0x00000B44 }, /* GL_CULL_FACE */
-+ { 5504, 0x00000B45 }, /* GL_CULL_FACE_MODE */
-+ { 5522, 0x000081AA }, /* GL_CULL_VERTEX_EXT */
-+ { 5541, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-+ { 5573, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
-+ { 5608, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */
-+ { 5629, 0x00000001 }, /* GL_CURRENT_BIT */
-+ { 5644, 0x00000B00 }, /* GL_CURRENT_COLOR */
-+ { 5661, 0x00008453 }, /* GL_CURRENT_FOG_COORD */
-+ { 5682, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */
-+ { 5708, 0x00000B01 }, /* GL_CURRENT_INDEX */
-+ { 5725, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */
-+ { 5747, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */
-+ { 5775, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */
-+ { 5796, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
-+ { 5830, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */
-+ { 5863, 0x00000B02 }, /* GL_CURRENT_NORMAL */
-+ { 5881, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-+ { 5911, 0x00008B8D }, /* GL_CURRENT_PROGRAM */
-+ { 5930, 0x00008865 }, /* GL_CURRENT_QUERY */
-+ { 5947, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */
-+ { 5968, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */
-+ { 5992, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */
-+ { 6019, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */
-+ { 6043, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */
-+ { 6070, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */
-+ { 6103, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
-+ { 6136, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */
-+ { 6163, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */
-+ { 6189, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */
-+ { 6214, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */
-+ { 6243, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */
-+ { 6265, 0x00000900 }, /* GL_CW */
-+ { 6271, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */
-+ { 6292, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */
-+ { 6313, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */
-+ { 6333, 0x00002101 }, /* GL_DECAL */
-+ { 6342, 0x00001E03 }, /* GL_DECR */
-+ { 6350, 0x00008508 }, /* GL_DECR_WRAP */
-+ { 6363, 0x00008508 }, /* GL_DECR_WRAP_EXT */
-+ { 6380, 0x00008B80 }, /* GL_DELETE_STATUS */
-+ { 6397, 0x00001801 }, /* GL_DEPTH */
-+ { 6406, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */
-+ { 6430, 0x00000D1F }, /* GL_DEPTH_BIAS */
-+ { 6444, 0x00000D56 }, /* GL_DEPTH_BITS */
-+ { 6458, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
-+ { 6478, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
-+ { 6503, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
-+ { 6523, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
-+ { 6541, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
-+ { 6562, 0x00001902 }, /* GL_DEPTH_COMPONENT */
-+ { 6581, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
-+ { 6602, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
-+ { 6627, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
-+ { 6653, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
-+ { 6674, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
-+ { 6699, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
-+ { 6725, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
-+ { 6746, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
-+ { 6771, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
-+ { 6797, 0x00000B74 }, /* GL_DEPTH_FUNC */
-+ { 6811, 0x00000B70 }, /* GL_DEPTH_RANGE */
-+ { 6826, 0x00000D1E }, /* GL_DEPTH_SCALE */
-+ { 6841, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
-+ { 6861, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-+ { 6889, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-+ { 6917, 0x00000B71 }, /* GL_DEPTH_TEST */
-+ { 6931, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
-+ { 6953, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
-+ { 6979, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
-+ { 6998, 0x00001201 }, /* GL_DIFFUSE */
-+ { 7009, 0x00000BD0 }, /* GL_DITHER */
-+ { 7019, 0x00000A02 }, /* GL_DOMAIN */
-+ { 7029, 0x00001100 }, /* GL_DONT_CARE */
-+ { 7042, 0x000086AE }, /* GL_DOT3_RGB */
-+ { 7054, 0x000086AF }, /* GL_DOT3_RGBA */
-+ { 7067, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
-+ { 7084, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
-+ { 7101, 0x000086AE }, /* GL_DOT3_RGB_ARB */
-+ { 7117, 0x00008740 }, /* GL_DOT3_RGB_EXT */
-+ { 7133, 0x0000140A }, /* GL_DOUBLE */
-+ { 7143, 0x00000C32 }, /* GL_DOUBLEBUFFER */
-+ { 7159, 0x00000C01 }, /* GL_DRAW_BUFFER */
-+ { 7174, 0x00008825 }, /* GL_DRAW_BUFFER0 */
-+ { 7190, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
-+ { 7210, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
-+ { 7230, 0x00008826 }, /* GL_DRAW_BUFFER1 */
-+ { 7246, 0x0000882F }, /* GL_DRAW_BUFFER10 */
-+ { 7263, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
-+ { 7284, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
-+ { 7305, 0x00008830 }, /* GL_DRAW_BUFFER11 */
-+ { 7322, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
-+ { 7343, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
-+ { 7364, 0x00008831 }, /* GL_DRAW_BUFFER12 */
-+ { 7381, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
-+ { 7402, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
-+ { 7423, 0x00008832 }, /* GL_DRAW_BUFFER13 */
-+ { 7440, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
-+ { 7461, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
-+ { 7482, 0x00008833 }, /* GL_DRAW_BUFFER14 */
-+ { 7499, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
-+ { 7520, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
-+ { 7541, 0x00008834 }, /* GL_DRAW_BUFFER15 */
-+ { 7558, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
-+ { 7579, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
-+ { 7600, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
-+ { 7620, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
-+ { 7640, 0x00008827 }, /* GL_DRAW_BUFFER2 */
-+ { 7656, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
-+ { 7676, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
-+ { 7696, 0x00008828 }, /* GL_DRAW_BUFFER3 */
-+ { 7712, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
-+ { 7732, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
-+ { 7752, 0x00008829 }, /* GL_DRAW_BUFFER4 */
-+ { 7768, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
-+ { 7788, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
-+ { 7808, 0x0000882A }, /* GL_DRAW_BUFFER5 */
-+ { 7824, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
-+ { 7844, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
-+ { 7864, 0x0000882B }, /* GL_DRAW_BUFFER6 */
-+ { 7880, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
-+ { 7900, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
-+ { 7920, 0x0000882C }, /* GL_DRAW_BUFFER7 */
-+ { 7936, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
-+ { 7956, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
-+ { 7976, 0x0000882D }, /* GL_DRAW_BUFFER8 */
-+ { 7992, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
-+ { 8012, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
-+ { 8032, 0x0000882E }, /* GL_DRAW_BUFFER9 */
-+ { 8048, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
-+ { 8068, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
-+ { 8088, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-+ { 8120, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
-+ { 8144, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
-+ { 8164, 0x00000304 }, /* GL_DST_ALPHA */
-+ { 8177, 0x00000306 }, /* GL_DST_COLOR */
-+ { 8190, 0x000088EA }, /* GL_DYNAMIC_COPY */
-+ { 8206, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
-+ { 8226, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
-+ { 8242, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
-+ { 8262, 0x000088E9 }, /* GL_DYNAMIC_READ */
-+ { 8278, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
-+ { 8298, 0x00000B43 }, /* GL_EDGE_FLAG */
-+ { 8311, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
-+ { 8330, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-+ { 8364, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
-+ { 8402, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
-+ { 8429, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-+ { 8455, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
-+ { 8479, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER_ARB */
-+ { 8507, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-+ { 8539, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
-+ { 8575, 0x00001600 }, /* GL_EMISSION */
-+ { 8587, 0x00002000 }, /* GL_ENABLE_BIT */
-+ { 8601, 0x00000202 }, /* GL_EQUAL */
-+ { 8610, 0x00001509 }, /* GL_EQUIV */
-+ { 8619, 0x00010000 }, /* GL_EVAL_BIT */
-+ { 8631, 0x00000800 }, /* GL_EXP */
-+ { 8638, 0x00000801 }, /* GL_EXP2 */
-+ { 8646, 0x00001F03 }, /* GL_EXTENSIONS */
-+ { 8660, 0x00002400 }, /* GL_EYE_LINEAR */
-+ { 8674, 0x00002502 }, /* GL_EYE_PLANE */
-+ { 8687, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
-+ { 8712, 0x0000855B }, /* GL_EYE_RADIAL_NV */
-+ { 8729, 0x00000000 }, /* GL_FALSE */
-+ { 8738, 0x00001101 }, /* GL_FASTEST */
-+ { 8749, 0x00001C01 }, /* GL_FEEDBACK */
-+ { 8761, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
-+ { 8788, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
-+ { 8812, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
-+ { 8836, 0x00001B02 }, /* GL_FILL */
-+ { 8844, 0x00001D00 }, /* GL_FLAT */
-+ { 8852, 0x00001406 }, /* GL_FLOAT */
-+ { 8861, 0x00008B5A }, /* GL_FLOAT_MAT2 */
-+ { 8875, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
-+ { 8893, 0x00008B5B }, /* GL_FLOAT_MAT3 */
-+ { 8907, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
-+ { 8925, 0x00008B5C }, /* GL_FLOAT_MAT4 */
-+ { 8939, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
-+ { 8957, 0x00008B50 }, /* GL_FLOAT_VEC2 */
-+ { 8971, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
-+ { 8989, 0x00008B51 }, /* GL_FLOAT_VEC3 */
-+ { 9003, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
-+ { 9021, 0x00008B52 }, /* GL_FLOAT_VEC4 */
-+ { 9035, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
-+ { 9053, 0x00000B60 }, /* GL_FOG */
-+ { 9060, 0x00000080 }, /* GL_FOG_BIT */
-+ { 9071, 0x00000B66 }, /* GL_FOG_COLOR */
-+ { 9084, 0x00008451 }, /* GL_FOG_COORD */
-+ { 9097, 0x00008451 }, /* GL_FOG_COORDINATE */
-+ { 9115, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
-+ { 9139, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-+ { 9178, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
-+ { 9221, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-+ { 9253, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-+ { 9284, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-+ { 9313, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
-+ { 9338, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
-+ { 9357, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
-+ { 9391, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
-+ { 9418, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
-+ { 9444, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
-+ { 9468, 0x00008450 }, /* GL_FOG_COORD_SRC */
-+ { 9485, 0x00000B62 }, /* GL_FOG_DENSITY */
-+ { 9500, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
-+ { 9524, 0x00000B64 }, /* GL_FOG_END */
-+ { 9535, 0x00000C54 }, /* GL_FOG_HINT */
-+ { 9547, 0x00000B61 }, /* GL_FOG_INDEX */
-+ { 9560, 0x00000B65 }, /* GL_FOG_MODE */
-+ { 9572, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
-+ { 9591, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
-+ { 9616, 0x00000B63 }, /* GL_FOG_START */
-+ { 9629, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
-+ { 9647, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
-+ { 9671, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
-+ { 9690, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
-+ { 9713, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-+ { 9748, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-+ { 9790, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-+ { 9832, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-+ { 9881, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-+ { 9933, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
-+ { 9977, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-+ { 10021, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
-+ { 10048, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-+ { 10076, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
-+ { 10095, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-+ { 10136, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-+ { 10177, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-+ { 10219, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-+ { 10270, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-+ { 10308, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-+ { 10357, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-+ { 10399, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-+ { 10431, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-+ { 10462, 0x00000404 }, /* GL_FRONT */
-+ { 10471, 0x00000408 }, /* GL_FRONT_AND_BACK */
-+ { 10489, 0x00000B46 }, /* GL_FRONT_FACE */
-+ { 10503, 0x00000400 }, /* GL_FRONT_LEFT */
-+ { 10517, 0x00000401 }, /* GL_FRONT_RIGHT */
-+ { 10532, 0x00008006 }, /* GL_FUNC_ADD */
-+ { 10544, 0x00008006 }, /* GL_FUNC_ADD_EXT */
-+ { 10560, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
-+ { 10585, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
-+ { 10614, 0x0000800A }, /* GL_FUNC_SUBTRACT */
-+ { 10631, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
-+ { 10652, 0x00008191 }, /* GL_GENERATE_MIPMAP */
-+ { 10671, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
-+ { 10695, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
-+ { 10724, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
-+ { 10748, 0x00000206 }, /* GL_GEQUAL */
-+ { 10758, 0x00008009 }, /* GL_GL_BLEND_EQUATION_RGB */
-+ { 10783, 0x00008C4A }, /* GL_GL_COMPRESSED_SLUMINANCE */
-+ { 10811, 0x00008C4B }, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */
-+ { 10845, 0x00008C48 }, /* GL_GL_COMPRESSED_SRGB */
-+ { 10867, 0x00008C49 }, /* GL_GL_COMPRESSED_SRGB_ALPHA */
-+ { 10895, 0x0000845F }, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */
-+ { 10932, 0x00008B65 }, /* GL_GL_FLOAT_MAT2x3 */
-+ { 10951, 0x00008B66 }, /* GL_GL_FLOAT_MAT2x4 */
-+ { 10970, 0x00008B67 }, /* GL_GL_FLOAT_MAT3x2 */
-+ { 10989, 0x00008B68 }, /* GL_GL_FLOAT_MAT3x4 */
-+ { 11008, 0x00008B69 }, /* GL_GL_FLOAT_MAT4x2 */
-+ { 11027, 0x00008B6A }, /* GL_GL_FLOAT_MAT4x3 */
-+ { 11046, 0x000088EB }, /* GL_GL_PIXEL_PACK_BUFFER */
-+ { 11070, 0x000088ED }, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */
-+ { 11102, 0x000088EC }, /* GL_GL_PIXEL_UNPACK_BUFFER */
-+ { 11128, 0x000088EF }, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */
-+ { 11162, 0x00008C46 }, /* GL_GL_SLUMINANCE */
-+ { 11179, 0x00008C47 }, /* GL_GL_SLUMINANCE8 */
-+ { 11197, 0x00008C45 }, /* GL_GL_SLUMINANCE8_ALPHA8 */
-+ { 11222, 0x00008C44 }, /* GL_GL_SLUMINANCE_ALPHA */
-+ { 11245, 0x00008C40 }, /* GL_GL_SRGB */
-+ { 11256, 0x00008C41 }, /* GL_GL_SRGB8 */
-+ { 11268, 0x00008C43 }, /* GL_GL_SRGB8_ALPHA8 */
-+ { 11287, 0x00008C42 }, /* GL_GL_SRGB_ALPHA */
-+ { 11304, 0x00000204 }, /* GL_GREATER */
-+ { 11315, 0x00001904 }, /* GL_GREEN */
-+ { 11324, 0x00000D19 }, /* GL_GREEN_BIAS */
-+ { 11338, 0x00000D53 }, /* GL_GREEN_BITS */
-+ { 11352, 0x00000D18 }, /* GL_GREEN_SCALE */
-+ { 11367, 0x00008000 }, /* GL_HINT_BIT */
-+ { 11379, 0x00008024 }, /* GL_HISTOGRAM */
-+ { 11392, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
-+ { 11416, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
-+ { 11444, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
-+ { 11467, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
-+ { 11494, 0x00008024 }, /* GL_HISTOGRAM_EXT */
-+ { 11511, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
-+ { 11531, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
-+ { 11555, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
-+ { 11579, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
-+ { 11607, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-+ { 11635, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
-+ { 11667, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
-+ { 11689, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
-+ { 11715, 0x0000802D }, /* GL_HISTOGRAM_SINK */
-+ { 11733, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
-+ { 11755, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
-+ { 11774, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
-+ { 11797, 0x0000862A }, /* GL_IDENTITY_NV */
-+ { 11812, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
-+ { 11832, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-+ { 11872, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-+ { 11910, 0x00001E02 }, /* GL_INCR */
-+ { 11918, 0x00008507 }, /* GL_INCR_WRAP */
-+ { 11931, 0x00008507 }, /* GL_INCR_WRAP_EXT */
-+ { 11948, 0x00008077 }, /* GL_INDEX_ARRAY */
-+ { 11963, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-+ { 11993, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
-+ { 12027, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
-+ { 12050, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
-+ { 12072, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
-+ { 12092, 0x00000D51 }, /* GL_INDEX_BITS */
-+ { 12106, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
-+ { 12127, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
-+ { 12145, 0x00000C30 }, /* GL_INDEX_MODE */
-+ { 12159, 0x00000D13 }, /* GL_INDEX_OFFSET */
-+ { 12175, 0x00000D12 }, /* GL_INDEX_SHIFT */
-+ { 12190, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
-+ { 12209, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
-+ { 12228, 0x00001404 }, /* GL_INT */
-+ { 12235, 0x00008049 }, /* GL_INTENSITY */
-+ { 12248, 0x0000804C }, /* GL_INTENSITY12 */
-+ { 12263, 0x0000804C }, /* GL_INTENSITY12_EXT */
-+ { 12282, 0x0000804D }, /* GL_INTENSITY16 */
-+ { 12297, 0x0000804D }, /* GL_INTENSITY16_EXT */
-+ { 12316, 0x0000804A }, /* GL_INTENSITY4 */
-+ { 12330, 0x0000804A }, /* GL_INTENSITY4_EXT */
-+ { 12348, 0x0000804B }, /* GL_INTENSITY8 */
-+ { 12362, 0x0000804B }, /* GL_INTENSITY8_EXT */
-+ { 12380, 0x00008049 }, /* GL_INTENSITY_EXT */
-+ { 12397, 0x00008575 }, /* GL_INTERPOLATE */
-+ { 12412, 0x00008575 }, /* GL_INTERPOLATE_ARB */
-+ { 12431, 0x00008575 }, /* GL_INTERPOLATE_EXT */
-+ { 12450, 0x00008B53 }, /* GL_INT_VEC2 */
-+ { 12462, 0x00008B53 }, /* GL_INT_VEC2_ARB */
-+ { 12478, 0x00008B54 }, /* GL_INT_VEC3 */
-+ { 12490, 0x00008B54 }, /* GL_INT_VEC3_ARB */
-+ { 12506, 0x00008B55 }, /* GL_INT_VEC4 */
-+ { 12518, 0x00008B55 }, /* GL_INT_VEC4_ARB */
-+ { 12534, 0x00000500 }, /* GL_INVALID_ENUM */
-+ { 12550, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-+ { 12587, 0x00000502 }, /* GL_INVALID_OPERATION */
-+ { 12608, 0x00000501 }, /* GL_INVALID_VALUE */
-+ { 12625, 0x0000862B }, /* GL_INVERSE_NV */
-+ { 12639, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
-+ { 12663, 0x0000150A }, /* GL_INVERT */
-+ { 12673, 0x00001E00 }, /* GL_KEEP */
-+ { 12681, 0x00000406 }, /* GL_LEFT */
-+ { 12689, 0x00000203 }, /* GL_LEQUAL */
-+ { 12699, 0x00000201 }, /* GL_LESS */
-+ { 12707, 0x00004000 }, /* GL_LIGHT0 */
-+ { 12717, 0x00004001 }, /* GL_LIGHT1 */
-+ { 12727, 0x00004002 }, /* GL_LIGHT2 */
-+ { 12737, 0x00004003 }, /* GL_LIGHT3 */
-+ { 12747, 0x00004004 }, /* GL_LIGHT4 */
-+ { 12757, 0x00004005 }, /* GL_LIGHT5 */
-+ { 12767, 0x00004006 }, /* GL_LIGHT6 */
-+ { 12777, 0x00004007 }, /* GL_LIGHT7 */
-+ { 12787, 0x00000B50 }, /* GL_LIGHTING */
-+ { 12799, 0x00000040 }, /* GL_LIGHTING_BIT */
-+ { 12815, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
-+ { 12838, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-+ { 12867, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
-+ { 12900, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-+ { 12928, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
-+ { 12952, 0x00001B01 }, /* GL_LINE */
-+ { 12960, 0x00002601 }, /* GL_LINEAR */
-+ { 12970, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
-+ { 12992, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-+ { 13022, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-+ { 13053, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
-+ { 13077, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
-+ { 13102, 0x00000001 }, /* GL_LINES */
-+ { 13111, 0x00000004 }, /* GL_LINE_BIT */
-+ { 13123, 0x00000002 }, /* GL_LINE_LOOP */
-+ { 13136, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
-+ { 13156, 0x00000B20 }, /* GL_LINE_SMOOTH */
-+ { 13171, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
-+ { 13191, 0x00000B24 }, /* GL_LINE_STIPPLE */
-+ { 13207, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
-+ { 13231, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
-+ { 13254, 0x00000003 }, /* GL_LINE_STRIP */
-+ { 13268, 0x00000702 }, /* GL_LINE_TOKEN */
-+ { 13282, 0x00000B21 }, /* GL_LINE_WIDTH */
-+ { 13296, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
-+ { 13322, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
-+ { 13342, 0x00008B82 }, /* GL_LINK_STATUS */
-+ { 13357, 0x00000B32 }, /* GL_LIST_BASE */
-+ { 13370, 0x00020000 }, /* GL_LIST_BIT */
-+ { 13382, 0x00000B33 }, /* GL_LIST_INDEX */
-+ { 13396, 0x00000B30 }, /* GL_LIST_MODE */
-+ { 13409, 0x00000101 }, /* GL_LOAD */
-+ { 13417, 0x00000BF1 }, /* GL_LOGIC_OP */
-+ { 13429, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
-+ { 13446, 0x00008CA1 }, /* GL_LOWER_LEFT */
-+ { 13460, 0x00001909 }, /* GL_LUMINANCE */
-+ { 13473, 0x00008041 }, /* GL_LUMINANCE12 */
-+ { 13488, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
-+ { 13511, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
-+ { 13538, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
-+ { 13560, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
-+ { 13586, 0x00008041 }, /* GL_LUMINANCE12_EXT */
-+ { 13605, 0x00008042 }, /* GL_LUMINANCE16 */
-+ { 13620, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
-+ { 13643, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
-+ { 13670, 0x00008042 }, /* GL_LUMINANCE16_EXT */
-+ { 13689, 0x0000803F }, /* GL_LUMINANCE4 */
-+ { 13703, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
-+ { 13724, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
-+ { 13749, 0x0000803F }, /* GL_LUMINANCE4_EXT */
-+ { 13767, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
-+ { 13788, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
-+ { 13813, 0x00008040 }, /* GL_LUMINANCE8 */
-+ { 13827, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
-+ { 13848, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
-+ { 13873, 0x00008040 }, /* GL_LUMINANCE8_EXT */
-+ { 13891, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
-+ { 13910, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
-+ { 13926, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
-+ { 13946, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
-+ { 13968, 0x00000D91 }, /* GL_MAP1_INDEX */
-+ { 13982, 0x00000D92 }, /* GL_MAP1_NORMAL */
-+ { 13997, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
-+ { 14021, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
-+ { 14045, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
-+ { 14069, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
-+ { 14093, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
-+ { 14110, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
-+ { 14127, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-+ { 14155, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-+ { 14184, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-+ { 14213, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-+ { 14242, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-+ { 14271, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-+ { 14300, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-+ { 14329, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-+ { 14357, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-+ { 14385, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-+ { 14413, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-+ { 14441, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-+ { 14469, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-+ { 14497, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-+ { 14525, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-+ { 14553, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-+ { 14581, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
-+ { 14597, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
-+ { 14617, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
-+ { 14639, 0x00000DB1 }, /* GL_MAP2_INDEX */
-+ { 14653, 0x00000DB2 }, /* GL_MAP2_NORMAL */
-+ { 14668, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
-+ { 14692, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
-+ { 14716, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
-+ { 14740, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
-+ { 14764, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
-+ { 14781, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
-+ { 14798, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-+ { 14826, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-+ { 14855, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-+ { 14884, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-+ { 14913, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-+ { 14942, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-+ { 14971, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-+ { 15000, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-+ { 15028, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-+ { 15056, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-+ { 15084, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-+ { 15112, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-+ { 15140, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-+ { 15168, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
-+ { 15196, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-+ { 15224, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-+ { 15252, 0x00000D10 }, /* GL_MAP_COLOR */
-+ { 15265, 0x00000D11 }, /* GL_MAP_STENCIL */
-+ { 15280, 0x000088C0 }, /* GL_MATRIX0_ARB */
-+ { 15295, 0x00008630 }, /* GL_MATRIX0_NV */
-+ { 15309, 0x000088CA }, /* GL_MATRIX10_ARB */
-+ { 15325, 0x000088CB }, /* GL_MATRIX11_ARB */
-+ { 15341, 0x000088CC }, /* GL_MATRIX12_ARB */
-+ { 15357, 0x000088CD }, /* GL_MATRIX13_ARB */
-+ { 15373, 0x000088CE }, /* GL_MATRIX14_ARB */
-+ { 15389, 0x000088CF }, /* GL_MATRIX15_ARB */
-+ { 15405, 0x000088D0 }, /* GL_MATRIX16_ARB */
-+ { 15421, 0x000088D1 }, /* GL_MATRIX17_ARB */
-+ { 15437, 0x000088D2 }, /* GL_MATRIX18_ARB */
-+ { 15453, 0x000088D3 }, /* GL_MATRIX19_ARB */
-+ { 15469, 0x000088C1 }, /* GL_MATRIX1_ARB */
-+ { 15484, 0x00008631 }, /* GL_MATRIX1_NV */
-+ { 15498, 0x000088D4 }, /* GL_MATRIX20_ARB */
-+ { 15514, 0x000088D5 }, /* GL_MATRIX21_ARB */
-+ { 15530, 0x000088D6 }, /* GL_MATRIX22_ARB */
-+ { 15546, 0x000088D7 }, /* GL_MATRIX23_ARB */
-+ { 15562, 0x000088D8 }, /* GL_MATRIX24_ARB */
-+ { 15578, 0x000088D9 }, /* GL_MATRIX25_ARB */
-+ { 15594, 0x000088DA }, /* GL_MATRIX26_ARB */
-+ { 15610, 0x000088DB }, /* GL_MATRIX27_ARB */
-+ { 15626, 0x000088DC }, /* GL_MATRIX28_ARB */
-+ { 15642, 0x000088DD }, /* GL_MATRIX29_ARB */
-+ { 15658, 0x000088C2 }, /* GL_MATRIX2_ARB */
-+ { 15673, 0x00008632 }, /* GL_MATRIX2_NV */
-+ { 15687, 0x000088DE }, /* GL_MATRIX30_ARB */
-+ { 15703, 0x000088DF }, /* GL_MATRIX31_ARB */
-+ { 15719, 0x000088C3 }, /* GL_MATRIX3_ARB */
-+ { 15734, 0x00008633 }, /* GL_MATRIX3_NV */
-+ { 15748, 0x000088C4 }, /* GL_MATRIX4_ARB */
-+ { 15763, 0x00008634 }, /* GL_MATRIX4_NV */
-+ { 15777, 0x000088C5 }, /* GL_MATRIX5_ARB */
-+ { 15792, 0x00008635 }, /* GL_MATRIX5_NV */
-+ { 15806, 0x000088C6 }, /* GL_MATRIX6_ARB */
-+ { 15821, 0x00008636 }, /* GL_MATRIX6_NV */
-+ { 15835, 0x000088C7 }, /* GL_MATRIX7_ARB */
-+ { 15850, 0x00008637 }, /* GL_MATRIX7_NV */
-+ { 15864, 0x000088C8 }, /* GL_MATRIX8_ARB */
-+ { 15879, 0x000088C9 }, /* GL_MATRIX9_ARB */
-+ { 15894, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
-+ { 15920, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-+ { 15954, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-+ { 15985, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-+ { 16018, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-+ { 16049, 0x00000BA0 }, /* GL_MATRIX_MODE */
-+ { 16064, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
-+ { 16086, 0x00008008 }, /* GL_MAX */
-+ { 16093, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
-+ { 16116, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-+ { 16148, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
-+ { 16174, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-+ { 16207, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-+ { 16233, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+ { 16267, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
-+ { 16286, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-+ { 16315, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-+ { 16347, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
-+ { 16383, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-+ { 16419, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
-+ { 16459, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
-+ { 16485, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
-+ { 16515, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
-+ { 16540, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
-+ { 16569, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-+ { 16598, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
-+ { 16631, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
-+ { 16651, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
-+ { 16675, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
-+ { 16699, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
-+ { 16723, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
-+ { 16748, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
-+ { 16766, 0x00008008 }, /* GL_MAX_EXT */
-+ { 16777, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-+ { 16812, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
-+ { 16851, 0x00000D31 }, /* GL_MAX_LIGHTS */
-+ { 16865, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
-+ { 16885, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-+ { 16923, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-+ { 16952, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
-+ { 16976, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
-+ { 17004, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
-+ { 17027, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-+ { 17064, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+ { 17100, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-+ { 17127, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-+ { 17156, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-+ { 17190, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-+ { 17226, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-+ { 17253, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-+ { 17285, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-+ { 17321, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-+ { 17350, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-+ { 17379, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
-+ { 17407, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-+ { 17445, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+ { 17489, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+ { 17532, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-+ { 17566, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+ { 17605, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-+ { 17642, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+ { 17680, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+ { 17723, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+ { 17766, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-+ { 17796, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-+ { 17827, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-+ { 17863, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+ { 17899, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
-+ { 17929, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-+ { 17963, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
-+ { 17996, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-+ { 18025, 0x00008504 }, /* GL_MAX_SHININESS_NV */
-+ { 18045, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
-+ { 18069, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
-+ { 18091, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
-+ { 18117, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-+ { 18144, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-+ { 18175, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
-+ { 18199, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-+ { 18233, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
-+ { 18253, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
-+ { 18280, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
-+ { 18301, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
-+ { 18326, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
-+ { 18351, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-+ { 18386, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
-+ { 18408, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
-+ { 18434, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
-+ { 18456, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-+ { 18482, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-+ { 18516, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
-+ { 18554, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-+ { 18587, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
-+ { 18624, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
-+ { 18648, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
-+ { 18669, 0x00008007 }, /* GL_MIN */
-+ { 18676, 0x0000802E }, /* GL_MINMAX */
-+ { 18686, 0x0000802E }, /* GL_MINMAX_EXT */
-+ { 18700, 0x0000802F }, /* GL_MINMAX_FORMAT */
-+ { 18717, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
-+ { 18738, 0x00008030 }, /* GL_MINMAX_SINK */
-+ { 18753, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
-+ { 18772, 0x00008007 }, /* GL_MIN_EXT */
-+ { 18783, 0x00008370 }, /* GL_MIRRORED_REPEAT */
-+ { 18802, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
-+ { 18825, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
-+ { 18848, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
-+ { 18868, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
-+ { 18888, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-+ { 18918, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
-+ { 18946, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-+ { 18974, 0x00001700 }, /* GL_MODELVIEW */
-+ { 18987, 0x00001700 }, /* GL_MODELVIEW0_ARB */
-+ { 19005, 0x0000872A }, /* GL_MODELVIEW10_ARB */
-+ { 19024, 0x0000872B }, /* GL_MODELVIEW11_ARB */
-+ { 19043, 0x0000872C }, /* GL_MODELVIEW12_ARB */
-+ { 19062, 0x0000872D }, /* GL_MODELVIEW13_ARB */
-+ { 19081, 0x0000872E }, /* GL_MODELVIEW14_ARB */
-+ { 19100, 0x0000872F }, /* GL_MODELVIEW15_ARB */
-+ { 19119, 0x00008730 }, /* GL_MODELVIEW16_ARB */
-+ { 19138, 0x00008731 }, /* GL_MODELVIEW17_ARB */
-+ { 19157, 0x00008732 }, /* GL_MODELVIEW18_ARB */
-+ { 19176, 0x00008733 }, /* GL_MODELVIEW19_ARB */
-+ { 19195, 0x0000850A }, /* GL_MODELVIEW1_ARB */
-+ { 19213, 0x00008734 }, /* GL_MODELVIEW20_ARB */
-+ { 19232, 0x00008735 }, /* GL_MODELVIEW21_ARB */
-+ { 19251, 0x00008736 }, /* GL_MODELVIEW22_ARB */
-+ { 19270, 0x00008737 }, /* GL_MODELVIEW23_ARB */
-+ { 19289, 0x00008738 }, /* GL_MODELVIEW24_ARB */
-+ { 19308, 0x00008739 }, /* GL_MODELVIEW25_ARB */
-+ { 19327, 0x0000873A }, /* GL_MODELVIEW26_ARB */
-+ { 19346, 0x0000873B }, /* GL_MODELVIEW27_ARB */
-+ { 19365, 0x0000873C }, /* GL_MODELVIEW28_ARB */
-+ { 19384, 0x0000873D }, /* GL_MODELVIEW29_ARB */
-+ { 19403, 0x00008722 }, /* GL_MODELVIEW2_ARB */
-+ { 19421, 0x0000873E }, /* GL_MODELVIEW30_ARB */
-+ { 19440, 0x0000873F }, /* GL_MODELVIEW31_ARB */
-+ { 19459, 0x00008723 }, /* GL_MODELVIEW3_ARB */
-+ { 19477, 0x00008724 }, /* GL_MODELVIEW4_ARB */
-+ { 19495, 0x00008725 }, /* GL_MODELVIEW5_ARB */
-+ { 19513, 0x00008726 }, /* GL_MODELVIEW6_ARB */
-+ { 19531, 0x00008727 }, /* GL_MODELVIEW7_ARB */
-+ { 19549, 0x00008728 }, /* GL_MODELVIEW8_ARB */
-+ { 19567, 0x00008729 }, /* GL_MODELVIEW9_ARB */
-+ { 19585, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
-+ { 19605, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
-+ { 19632, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
-+ { 19657, 0x00002100 }, /* GL_MODULATE */
-+ { 19669, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
-+ { 19689, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
-+ { 19716, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
-+ { 19741, 0x00000103 }, /* GL_MULT */
-+ { 19749, 0x0000809D }, /* GL_MULTISAMPLE */
-+ { 19764, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
-+ { 19784, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
-+ { 19803, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
-+ { 19822, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
-+ { 19846, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
-+ { 19869, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-+ { 19899, 0x00002A25 }, /* GL_N3F_V3F */
-+ { 19910, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
-+ { 19930, 0x0000150E }, /* GL_NAND */
-+ { 19938, 0x00002600 }, /* GL_NEAREST */
-+ { 19949, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-+ { 19980, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-+ { 20012, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
-+ { 20037, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
-+ { 20063, 0x00000200 }, /* GL_NEVER */
-+ { 20072, 0x00001102 }, /* GL_NICEST */
-+ { 20082, 0x00000000 }, /* GL_NONE */
-+ { 20090, 0x00001505 }, /* GL_NOOP */
-+ { 20098, 0x00001508 }, /* GL_NOR */
-+ { 20105, 0x00000BA1 }, /* GL_NORMALIZE */
-+ { 20118, 0x00008075 }, /* GL_NORMAL_ARRAY */
-+ { 20134, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-+ { 20165, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
-+ { 20200, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
-+ { 20224, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
-+ { 20247, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
-+ { 20268, 0x00008511 }, /* GL_NORMAL_MAP */
-+ { 20282, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
-+ { 20300, 0x00008511 }, /* GL_NORMAL_MAP_NV */
-+ { 20317, 0x00000205 }, /* GL_NOTEQUAL */
-+ { 20329, 0x00000000 }, /* GL_NO_ERROR */
-+ { 20341, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-+ { 20375, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
-+ { 20413, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
-+ { 20445, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
-+ { 20487, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
-+ { 20517, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
-+ { 20557, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
-+ { 20588, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
-+ { 20617, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
-+ { 20645, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
-+ { 20675, 0x00002401 }, /* GL_OBJECT_LINEAR */
-+ { 20692, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
-+ { 20718, 0x00002501 }, /* GL_OBJECT_PLANE */
-+ { 20734, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
-+ { 20769, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
-+ { 20791, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
-+ { 20810, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
-+ { 20840, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
-+ { 20861, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
-+ { 20889, 0x00000001 }, /* GL_ONE */
-+ { 20896, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-+ { 20924, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
-+ { 20956, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
-+ { 20984, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
-+ { 21016, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
-+ { 21039, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
-+ { 21062, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
-+ { 21085, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
-+ { 21108, 0x00008598 }, /* GL_OPERAND0_ALPHA */
-+ { 21126, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
-+ { 21148, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
-+ { 21170, 0x00008590 }, /* GL_OPERAND0_RGB */
-+ { 21186, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
-+ { 21206, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
-+ { 21226, 0x00008599 }, /* GL_OPERAND1_ALPHA */
-+ { 21244, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
-+ { 21266, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
-+ { 21288, 0x00008591 }, /* GL_OPERAND1_RGB */
-+ { 21304, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
-+ { 21324, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
-+ { 21344, 0x0000859A }, /* GL_OPERAND2_ALPHA */
-+ { 21362, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
-+ { 21384, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
-+ { 21406, 0x00008592 }, /* GL_OPERAND2_RGB */
-+ { 21422, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
-+ { 21442, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
-+ { 21462, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
-+ { 21483, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
-+ { 21502, 0x00001507 }, /* GL_OR */
-+ { 21508, 0x00000A01 }, /* GL_ORDER */
-+ { 21517, 0x0000150D }, /* GL_OR_INVERTED */
-+ { 21532, 0x0000150B }, /* GL_OR_REVERSE */
-+ { 21546, 0x00000505 }, /* GL_OUT_OF_MEMORY */
-+ { 21563, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
-+ { 21581, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
-+ { 21602, 0x00008758 }, /* GL_PACK_INVERT_MESA */
-+ { 21622, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
-+ { 21640, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
-+ { 21659, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
-+ { 21679, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
-+ { 21699, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
-+ { 21717, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
-+ { 21736, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
-+ { 21761, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
-+ { 21785, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
-+ { 21806, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
-+ { 21828, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
-+ { 21850, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
-+ { 21875, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
-+ { 21899, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
-+ { 21920, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
-+ { 21942, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
-+ { 21964, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
-+ { 21986, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
-+ { 22017, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
-+ { 22037, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-+ { 22062, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
-+ { 22082, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-+ { 22107, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
-+ { 22127, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-+ { 22152, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
-+ { 22172, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-+ { 22197, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
-+ { 22217, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-+ { 22242, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
-+ { 22262, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-+ { 22287, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
-+ { 22307, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-+ { 22332, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
-+ { 22352, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-+ { 22377, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
-+ { 22397, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-+ { 22422, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
-+ { 22442, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-+ { 22467, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
-+ { 22485, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
-+ { 22518, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
-+ { 22543, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
-+ { 22578, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
-+ { 22605, 0x00001B00 }, /* GL_POINT */
-+ { 22614, 0x00000000 }, /* GL_POINTS */
-+ { 22624, 0x00000002 }, /* GL_POINT_BIT */
-+ { 22637, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
-+ { 22667, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
-+ { 22701, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
-+ { 22735, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
-+ { 22770, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
-+ { 22799, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
-+ { 22832, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
-+ { 22865, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
-+ { 22899, 0x00000B11 }, /* GL_POINT_SIZE */
-+ { 22913, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
-+ { 22939, 0x00008127 }, /* GL_POINT_SIZE_MAX */
-+ { 22957, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
-+ { 22979, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
-+ { 23001, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
-+ { 23024, 0x00008126 }, /* GL_POINT_SIZE_MIN */
-+ { 23042, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
-+ { 23064, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
-+ { 23086, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
-+ { 23109, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
-+ { 23129, 0x00000B10 }, /* GL_POINT_SMOOTH */
-+ { 23145, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
-+ { 23166, 0x00008861 }, /* GL_POINT_SPRITE */
-+ { 23182, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
-+ { 23202, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
-+ { 23231, 0x00008861 }, /* GL_POINT_SPRITE_NV */
-+ { 23250, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
-+ { 23276, 0x00000701 }, /* GL_POINT_TOKEN */
-+ { 23291, 0x00000009 }, /* GL_POLYGON */
-+ { 23302, 0x00000008 }, /* GL_POLYGON_BIT */
-+ { 23317, 0x00000B40 }, /* GL_POLYGON_MODE */
-+ { 23333, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
-+ { 23356, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
-+ { 23381, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
-+ { 23404, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
-+ { 23427, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
-+ { 23451, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
-+ { 23475, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
-+ { 23493, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
-+ { 23516, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
-+ { 23535, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
-+ { 23558, 0x00000703 }, /* GL_POLYGON_TOKEN */
-+ { 23575, 0x00001203 }, /* GL_POSITION */
-+ { 23587, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-+ { 23619, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
-+ { 23655, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-+ { 23688, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
-+ { 23725, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-+ { 23756, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
-+ { 23791, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-+ { 23823, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
-+ { 23859, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-+ { 23892, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-+ { 23924, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
-+ { 23960, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-+ { 23993, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
-+ { 24030, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-+ { 24060, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
-+ { 24094, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-+ { 24125, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
-+ { 24160, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-+ { 24191, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
-+ { 24226, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-+ { 24258, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
-+ { 24294, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-+ { 24324, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
-+ { 24358, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-+ { 24389, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
-+ { 24424, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-+ { 24456, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-+ { 24487, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
-+ { 24522, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-+ { 24554, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
-+ { 24590, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
-+ { 24619, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
-+ { 24652, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
-+ { 24682, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
-+ { 24716, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-+ { 24755, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-+ { 24788, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-+ { 24828, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-+ { 24862, 0x00008578 }, /* GL_PREVIOUS */
-+ { 24874, 0x00008578 }, /* GL_PREVIOUS_ARB */
-+ { 24890, 0x00008578 }, /* GL_PREVIOUS_EXT */
-+ { 24906, 0x00008577 }, /* GL_PRIMARY_COLOR */
-+ { 24923, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
-+ { 24944, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
-+ { 24965, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-+ { 24998, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+ { 25030, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
-+ { 25053, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
-+ { 25076, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
-+ { 25106, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
-+ { 25135, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
-+ { 25163, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
-+ { 25185, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-+ { 25213, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-+ { 25241, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
-+ { 25263, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
-+ { 25284, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+ { 25324, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+ { 25363, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-+ { 25393, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+ { 25428, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-+ { 25461, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+ { 25495, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+ { 25534, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+ { 25573, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
-+ { 25595, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
-+ { 25621, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
-+ { 25645, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
-+ { 25668, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
-+ { 25690, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
-+ { 25711, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
-+ { 25732, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
-+ { 25759, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-+ { 25791, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+ { 25823, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-+ { 25858, 0x00001701 }, /* GL_PROJECTION */
-+ { 25872, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
-+ { 25893, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
-+ { 25919, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
-+ { 25940, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
-+ { 25959, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
-+ { 25982, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-+ { 26021, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-+ { 26059, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
-+ { 26079, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-+ { 26109, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
-+ { 26133, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
-+ { 26153, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-+ { 26183, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
-+ { 26207, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
-+ { 26227, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-+ { 26260, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
-+ { 26286, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
-+ { 26316, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-+ { 26347, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
-+ { 26377, 0x00002003 }, /* GL_Q */
-+ { 26382, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
-+ { 26407, 0x00000007 }, /* GL_QUADS */
-+ { 26416, 0x00008614 }, /* GL_QUAD_MESH_SUN */
-+ { 26433, 0x00000008 }, /* GL_QUAD_STRIP */
-+ { 26447, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
-+ { 26469, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
-+ { 26495, 0x00008866 }, /* GL_QUERY_RESULT */
-+ { 26511, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
-+ { 26531, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
-+ { 26557, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
-+ { 26587, 0x00002002 }, /* GL_R */
-+ { 26592, 0x00002A10 }, /* GL_R3_G3_B2 */
-+ { 26604, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-+ { 26637, 0x00000C02 }, /* GL_READ_BUFFER */
-+ { 26652, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-+ { 26684, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
-+ { 26708, 0x000088B8 }, /* GL_READ_ONLY */
-+ { 26721, 0x000088B8 }, /* GL_READ_ONLY_ARB */
-+ { 26738, 0x000088BA }, /* GL_READ_WRITE */
-+ { 26752, 0x000088BA }, /* GL_READ_WRITE_ARB */
-+ { 26770, 0x00001903 }, /* GL_RED */
-+ { 26777, 0x00008016 }, /* GL_REDUCE */
-+ { 26787, 0x00008016 }, /* GL_REDUCE_EXT */
-+ { 26801, 0x00000D15 }, /* GL_RED_BIAS */
-+ { 26813, 0x00000D52 }, /* GL_RED_BITS */
-+ { 26825, 0x00000D14 }, /* GL_RED_SCALE */
-+ { 26838, 0x00008512 }, /* GL_REFLECTION_MAP */
-+ { 26856, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
-+ { 26878, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
-+ { 26899, 0x00001C00 }, /* GL_RENDER */
-+ { 26909, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
-+ { 26937, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
-+ { 26957, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
-+ { 26984, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-+ { 27020, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
-+ { 27046, 0x00001F01 }, /* GL_RENDERER */
-+ { 27058, 0x00000C40 }, /* GL_RENDER_MODE */
-+ { 27073, 0x00002901 }, /* GL_REPEAT */
-+ { 27083, 0x00001E01 }, /* GL_REPLACE */
-+ { 27094, 0x00008062 }, /* GL_REPLACE_EXT */
-+ { 27109, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
-+ { 27132, 0x0000803A }, /* GL_RESCALE_NORMAL */
-+ { 27150, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
-+ { 27172, 0x00000102 }, /* GL_RETURN */
-+ { 27182, 0x00001907 }, /* GL_RGB */
-+ { 27189, 0x00008052 }, /* GL_RGB10 */
-+ { 27198, 0x00008059 }, /* GL_RGB10_A2 */
-+ { 27210, 0x00008059 }, /* GL_RGB10_A2_EXT */
-+ { 27226, 0x00008052 }, /* GL_RGB10_EXT */
-+ { 27239, 0x00008053 }, /* GL_RGB12 */
-+ { 27248, 0x00008053 }, /* GL_RGB12_EXT */
-+ { 27261, 0x00008054 }, /* GL_RGB16 */
-+ { 27270, 0x00008054 }, /* GL_RGB16_EXT */
-+ { 27283, 0x0000804E }, /* GL_RGB2_EXT */
-+ { 27295, 0x0000804F }, /* GL_RGB4 */
-+ { 27303, 0x0000804F }, /* GL_RGB4_EXT */
-+ { 27315, 0x000083A1 }, /* GL_RGB4_S3TC */
-+ { 27328, 0x00008050 }, /* GL_RGB5 */
-+ { 27336, 0x00008057 }, /* GL_RGB5_A1 */
-+ { 27347, 0x00008057 }, /* GL_RGB5_A1_EXT */
-+ { 27362, 0x00008050 }, /* GL_RGB5_EXT */
-+ { 27374, 0x00008051 }, /* GL_RGB8 */
-+ { 27382, 0x00008051 }, /* GL_RGB8_EXT */
-+ { 27394, 0x00001908 }, /* GL_RGBA */
-+ { 27402, 0x0000805A }, /* GL_RGBA12 */
-+ { 27412, 0x0000805A }, /* GL_RGBA12_EXT */
-+ { 27426, 0x0000805B }, /* GL_RGBA16 */
-+ { 27436, 0x0000805B }, /* GL_RGBA16_EXT */
-+ { 27450, 0x00008055 }, /* GL_RGBA2 */
-+ { 27459, 0x00008055 }, /* GL_RGBA2_EXT */
-+ { 27472, 0x00008056 }, /* GL_RGBA4 */
-+ { 27481, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
-+ { 27500, 0x00008056 }, /* GL_RGBA4_EXT */
-+ { 27513, 0x000083A3 }, /* GL_RGBA4_S3TC */
-+ { 27527, 0x00008058 }, /* GL_RGBA8 */
-+ { 27536, 0x00008058 }, /* GL_RGBA8_EXT */
-+ { 27549, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
-+ { 27567, 0x00000C31 }, /* GL_RGBA_MODE */
-+ { 27580, 0x000083A2 }, /* GL_RGBA_S3TC */
-+ { 27593, 0x000083A0 }, /* GL_RGB_S3TC */
-+ { 27605, 0x00008573 }, /* GL_RGB_SCALE */
-+ { 27618, 0x00008573 }, /* GL_RGB_SCALE_ARB */
-+ { 27635, 0x00008573 }, /* GL_RGB_SCALE_EXT */
-+ { 27652, 0x00000407 }, /* GL_RIGHT */
-+ { 27661, 0x00002000 }, /* GL_S */
-+ { 27666, 0x00008B5D }, /* GL_SAMPLER_1D */
-+ { 27680, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
-+ { 27701, 0x00008B5E }, /* GL_SAMPLER_2D */
-+ { 27715, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
-+ { 27736, 0x00008B5F }, /* GL_SAMPLER_3D */
-+ { 27750, 0x00008B60 }, /* GL_SAMPLER_CUBE */
-+ { 27766, 0x000080A9 }, /* GL_SAMPLES */
-+ { 27777, 0x000086B4 }, /* GL_SAMPLES_3DFX */
-+ { 27793, 0x000080A9 }, /* GL_SAMPLES_ARB */
-+ { 27808, 0x00008914 }, /* GL_SAMPLES_PASSED */
-+ { 27826, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
-+ { 27848, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-+ { 27876, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
-+ { 27908, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
-+ { 27931, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
-+ { 27958, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
-+ { 27976, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
-+ { 27999, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
-+ { 28021, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
-+ { 28040, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
-+ { 28063, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
-+ { 28089, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
-+ { 28119, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
-+ { 28144, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
-+ { 28173, 0x00080000 }, /* GL_SCISSOR_BIT */
-+ { 28188, 0x00000C10 }, /* GL_SCISSOR_BOX */
-+ { 28203, 0x00000C11 }, /* GL_SCISSOR_TEST */
-+ { 28219, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
-+ { 28244, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-+ { 28284, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
-+ { 28328, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-+ { 28361, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-+ { 28391, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-+ { 28423, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-+ { 28453, 0x00001C02 }, /* GL_SELECT */
-+ { 28463, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
-+ { 28491, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
-+ { 28516, 0x00008012 }, /* GL_SEPARABLE_2D */
-+ { 28532, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
-+ { 28559, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
-+ { 28590, 0x0000150F }, /* GL_SET */
-+ { 28597, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
-+ { 28618, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
-+ { 28642, 0x00008B4F }, /* GL_SHADER_TYPE */
-+ { 28657, 0x00000B54 }, /* GL_SHADE_MODEL */
-+ { 28672, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
-+ { 28700, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
-+ { 28723, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-+ { 28753, 0x00001601 }, /* GL_SHININESS */
-+ { 28766, 0x00001402 }, /* GL_SHORT */
-+ { 28775, 0x000081F9 }, /* GL_SINGLE_COLOR */
-+ { 28791, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
-+ { 28811, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
-+ { 28830, 0x00001D01 }, /* GL_SMOOTH */
-+ { 28840, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
-+ { 28873, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
-+ { 28900, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
-+ { 28933, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
-+ { 28960, 0x00008588 }, /* GL_SOURCE0_ALPHA */
-+ { 28977, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
-+ { 28998, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
-+ { 29019, 0x00008580 }, /* GL_SOURCE0_RGB */
-+ { 29034, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
-+ { 29053, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
-+ { 29072, 0x00008589 }, /* GL_SOURCE1_ALPHA */
-+ { 29089, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
-+ { 29110, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
-+ { 29131, 0x00008581 }, /* GL_SOURCE1_RGB */
-+ { 29146, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
-+ { 29165, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
-+ { 29184, 0x0000858A }, /* GL_SOURCE2_ALPHA */
-+ { 29201, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
-+ { 29222, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
-+ { 29243, 0x00008582 }, /* GL_SOURCE2_RGB */
-+ { 29258, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
-+ { 29277, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
-+ { 29296, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
-+ { 29316, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
-+ { 29334, 0x00001202 }, /* GL_SPECULAR */
-+ { 29346, 0x00002402 }, /* GL_SPHERE_MAP */
-+ { 29360, 0x00001206 }, /* GL_SPOT_CUTOFF */
-+ { 29375, 0x00001204 }, /* GL_SPOT_DIRECTION */
-+ { 29393, 0x00001205 }, /* GL_SPOT_EXPONENT */
-+ { 29410, 0x00008588 }, /* GL_SRC0_ALPHA */
-+ { 29424, 0x00008580 }, /* GL_SRC0_RGB */
-+ { 29436, 0x00008589 }, /* GL_SRC1_ALPHA */
-+ { 29450, 0x00008581 }, /* GL_SRC1_RGB */
-+ { 29462, 0x0000858A }, /* GL_SRC2_ALPHA */
-+ { 29476, 0x00008582 }, /* GL_SRC2_RGB */
-+ { 29488, 0x00000302 }, /* GL_SRC_ALPHA */
-+ { 29501, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
-+ { 29523, 0x00000300 }, /* GL_SRC_COLOR */
-+ { 29536, 0x00000503 }, /* GL_STACK_OVERFLOW */
-+ { 29554, 0x00000504 }, /* GL_STACK_UNDERFLOW */
-+ { 29573, 0x000088E6 }, /* GL_STATIC_COPY */
-+ { 29588, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
-+ { 29607, 0x000088E4 }, /* GL_STATIC_DRAW */
-+ { 29622, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
-+ { 29641, 0x000088E5 }, /* GL_STATIC_READ */
-+ { 29656, 0x000088E5 }, /* GL_STATIC_READ_ARB */
-+ { 29675, 0x00001802 }, /* GL_STENCIL */
-+ { 29686, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
-+ { 29712, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
-+ { 29733, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
-+ { 29754, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-+ { 29786, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-+ { 29818, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
-+ { 29838, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
-+ { 29865, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
-+ { 29891, 0x00000D57 }, /* GL_STENCIL_BITS */
-+ { 29907, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
-+ { 29929, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
-+ { 29952, 0x00000B94 }, /* GL_STENCIL_FAIL */
-+ { 29968, 0x00000B92 }, /* GL_STENCIL_FUNC */
-+ { 29984, 0x00001901 }, /* GL_STENCIL_INDEX */
-+ { 30001, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
-+ { 30024, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
-+ { 30046, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
-+ { 30068, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
-+ { 30090, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
-+ { 30111, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
-+ { 30138, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
-+ { 30165, 0x00000B97 }, /* GL_STENCIL_REF */
-+ { 30180, 0x00000B90 }, /* GL_STENCIL_TEST */
-+ { 30196, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-+ { 30225, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
-+ { 30247, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
-+ { 30268, 0x00000C33 }, /* GL_STEREO */
-+ { 30278, 0x000088E2 }, /* GL_STREAM_COPY */
-+ { 30293, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
-+ { 30312, 0x000088E0 }, /* GL_STREAM_DRAW */
-+ { 30327, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
-+ { 30346, 0x000088E1 }, /* GL_STREAM_READ */
-+ { 30361, 0x000088E1 }, /* GL_STREAM_READ_ARB */
-+ { 30380, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
-+ { 30397, 0x000084E7 }, /* GL_SUBTRACT */
-+ { 30409, 0x000084E7 }, /* GL_SUBTRACT_ARB */
-+ { 30425, 0x00002001 }, /* GL_T */
-+ { 30430, 0x00002A2A }, /* GL_T2F_C3F_V3F */
-+ { 30445, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
-+ { 30464, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
-+ { 30480, 0x00002A2B }, /* GL_T2F_N3F_V3F */
-+ { 30495, 0x00002A27 }, /* GL_T2F_V3F */
-+ { 30506, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
-+ { 30525, 0x00002A28 }, /* GL_T4F_V4F */
-+ { 30536, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
-+ { 30559, 0x00001702 }, /* GL_TEXTURE */
-+ { 30570, 0x000084C0 }, /* GL_TEXTURE0 */
-+ { 30582, 0x000084C0 }, /* GL_TEXTURE0_ARB */
-+ { 30598, 0x000084C1 }, /* GL_TEXTURE1 */
-+ { 30610, 0x000084CA }, /* GL_TEXTURE10 */
-+ { 30623, 0x000084CA }, /* GL_TEXTURE10_ARB */
-+ { 30640, 0x000084CB }, /* GL_TEXTURE11 */
-+ { 30653, 0x000084CB }, /* GL_TEXTURE11_ARB */
-+ { 30670, 0x000084CC }, /* GL_TEXTURE12 */
-+ { 30683, 0x000084CC }, /* GL_TEXTURE12_ARB */
-+ { 30700, 0x000084CD }, /* GL_TEXTURE13 */
-+ { 30713, 0x000084CD }, /* GL_TEXTURE13_ARB */
-+ { 30730, 0x000084CE }, /* GL_TEXTURE14 */
-+ { 30743, 0x000084CE }, /* GL_TEXTURE14_ARB */
-+ { 30760, 0x000084CF }, /* GL_TEXTURE15 */
-+ { 30773, 0x000084CF }, /* GL_TEXTURE15_ARB */
-+ { 30790, 0x000084D0 }, /* GL_TEXTURE16 */
-+ { 30803, 0x000084D0 }, /* GL_TEXTURE16_ARB */
-+ { 30820, 0x000084D1 }, /* GL_TEXTURE17 */
-+ { 30833, 0x000084D1 }, /* GL_TEXTURE17_ARB */
-+ { 30850, 0x000084D2 }, /* GL_TEXTURE18 */
-+ { 30863, 0x000084D2 }, /* GL_TEXTURE18_ARB */
-+ { 30880, 0x000084D3 }, /* GL_TEXTURE19 */
-+ { 30893, 0x000084D3 }, /* GL_TEXTURE19_ARB */
-+ { 30910, 0x000084C1 }, /* GL_TEXTURE1_ARB */
-+ { 30926, 0x000084C2 }, /* GL_TEXTURE2 */
-+ { 30938, 0x000084D4 }, /* GL_TEXTURE20 */
-+ { 30951, 0x000084D4 }, /* GL_TEXTURE20_ARB */
-+ { 30968, 0x000084D5 }, /* GL_TEXTURE21 */
-+ { 30981, 0x000084D5 }, /* GL_TEXTURE21_ARB */
-+ { 30998, 0x000084D6 }, /* GL_TEXTURE22 */
-+ { 31011, 0x000084D6 }, /* GL_TEXTURE22_ARB */
-+ { 31028, 0x000084D7 }, /* GL_TEXTURE23 */
-+ { 31041, 0x000084D7 }, /* GL_TEXTURE23_ARB */
-+ { 31058, 0x000084D8 }, /* GL_TEXTURE24 */
-+ { 31071, 0x000084D8 }, /* GL_TEXTURE24_ARB */
-+ { 31088, 0x000084D9 }, /* GL_TEXTURE25 */
-+ { 31101, 0x000084D9 }, /* GL_TEXTURE25_ARB */
-+ { 31118, 0x000084DA }, /* GL_TEXTURE26 */
-+ { 31131, 0x000084DA }, /* GL_TEXTURE26_ARB */
-+ { 31148, 0x000084DB }, /* GL_TEXTURE27 */
-+ { 31161, 0x000084DB }, /* GL_TEXTURE27_ARB */
-+ { 31178, 0x000084DC }, /* GL_TEXTURE28 */
-+ { 31191, 0x000084DC }, /* GL_TEXTURE28_ARB */
-+ { 31208, 0x000084DD }, /* GL_TEXTURE29 */
-+ { 31221, 0x000084DD }, /* GL_TEXTURE29_ARB */
-+ { 31238, 0x000084C2 }, /* GL_TEXTURE2_ARB */
-+ { 31254, 0x000084C3 }, /* GL_TEXTURE3 */
-+ { 31266, 0x000084DE }, /* GL_TEXTURE30 */
-+ { 31279, 0x000084DE }, /* GL_TEXTURE30_ARB */
-+ { 31296, 0x000084DF }, /* GL_TEXTURE31 */
-+ { 31309, 0x000084DF }, /* GL_TEXTURE31_ARB */
-+ { 31326, 0x000084C3 }, /* GL_TEXTURE3_ARB */
-+ { 31342, 0x000084C4 }, /* GL_TEXTURE4 */
-+ { 31354, 0x000084C4 }, /* GL_TEXTURE4_ARB */
-+ { 31370, 0x000084C5 }, /* GL_TEXTURE5 */
-+ { 31382, 0x000084C5 }, /* GL_TEXTURE5_ARB */
-+ { 31398, 0x000084C6 }, /* GL_TEXTURE6 */
-+ { 31410, 0x000084C6 }, /* GL_TEXTURE6_ARB */
-+ { 31426, 0x000084C7 }, /* GL_TEXTURE7 */
-+ { 31438, 0x000084C7 }, /* GL_TEXTURE7_ARB */
-+ { 31454, 0x000084C8 }, /* GL_TEXTURE8 */
-+ { 31466, 0x000084C8 }, /* GL_TEXTURE8_ARB */
-+ { 31482, 0x000084C9 }, /* GL_TEXTURE9 */
-+ { 31494, 0x000084C9 }, /* GL_TEXTURE9_ARB */
-+ { 31510, 0x00000DE0 }, /* GL_TEXTURE_1D */
-+ { 31524, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
-+ { 31548, 0x00000DE1 }, /* GL_TEXTURE_2D */
-+ { 31562, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
-+ { 31586, 0x0000806F }, /* GL_TEXTURE_3D */
-+ { 31600, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
-+ { 31622, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
-+ { 31648, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
-+ { 31670, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
-+ { 31692, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-+ { 31724, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
-+ { 31746, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-+ { 31778, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
-+ { 31800, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
-+ { 31828, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
-+ { 31860, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-+ { 31893, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
-+ { 31925, 0x00040000 }, /* GL_TEXTURE_BIT */
-+ { 31940, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
-+ { 31961, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
-+ { 31986, 0x00001005 }, /* GL_TEXTURE_BORDER */
-+ { 32004, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
-+ { 32028, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-+ { 32059, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-+ { 32089, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-+ { 32119, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-+ { 32154, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-+ { 32185, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+ { 32223, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
-+ { 32250, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-+ { 32282, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-+ { 32316, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
-+ { 32340, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
-+ { 32368, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
-+ { 32392, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
-+ { 32420, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-+ { 32453, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
-+ { 32477, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
-+ { 32499, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
-+ { 32521, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
-+ { 32547, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
-+ { 32581, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-+ { 32614, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
-+ { 32651, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
-+ { 32679, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
-+ { 32711, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
-+ { 32734, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-+ { 32772, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
-+ { 32814, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-+ { 32845, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-+ { 32873, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-+ { 32903, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-+ { 32931, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
-+ { 32951, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
-+ { 32975, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-+ { 33006, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
-+ { 33041, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-+ { 33072, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
-+ { 33107, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-+ { 33138, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
-+ { 33173, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-+ { 33204, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
-+ { 33239, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-+ { 33270, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
-+ { 33305, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-+ { 33336, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
-+ { 33371, 0x00008071 }, /* GL_TEXTURE_DEPTH */
-+ { 33388, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
-+ { 33410, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
-+ { 33436, 0x00002300 }, /* GL_TEXTURE_ENV */
-+ { 33451, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
-+ { 33472, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
-+ { 33492, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
-+ { 33518, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
-+ { 33538, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
-+ { 33555, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
-+ { 33572, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
-+ { 33589, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
-+ { 33606, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
-+ { 33631, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
-+ { 33653, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
-+ { 33679, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
-+ { 33697, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
-+ { 33723, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
-+ { 33749, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
-+ { 33779, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
-+ { 33806, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
-+ { 33831, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
-+ { 33851, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
-+ { 33875, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-+ { 33902, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-+ { 33929, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-+ { 33956, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
-+ { 33982, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
-+ { 34012, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
-+ { 34034, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
-+ { 34052, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-+ { 34082, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-+ { 34110, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-+ { 34138, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-+ { 34166, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
-+ { 34187, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
-+ { 34206, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
-+ { 34228, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
-+ { 34247, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
-+ { 34267, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
-+ { 34292, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
-+ { 34316, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
-+ { 34336, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
-+ { 34360, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
-+ { 34380, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
-+ { 34403, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
-+ { 34428, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-+ { 34462, 0x00001000 }, /* GL_TEXTURE_WIDTH */
-+ { 34479, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
-+ { 34497, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
-+ { 34515, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
-+ { 34533, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
-+ { 34553, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
-+ { 34572, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-+ { 34601, 0x00001000 }, /* GL_TRANSFORM_BIT */
-+ { 34618, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
-+ { 34644, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
-+ { 34674, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-+ { 34706, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-+ { 34736, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
-+ { 34770, 0x0000862C }, /* GL_TRANSPOSE_NV */
-+ { 34786, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-+ { 34817, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
-+ { 34852, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-+ { 34880, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
-+ { 34912, 0x00000004 }, /* GL_TRIANGLES */
-+ { 34925, 0x00000006 }, /* GL_TRIANGLE_FAN */
-+ { 34941, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
-+ { 34962, 0x00000005 }, /* GL_TRIANGLE_STRIP */
-+ { 34980, 0x00000001 }, /* GL_TRUE */
-+ { 34988, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
-+ { 35008, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
-+ { 35031, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
-+ { 35051, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
-+ { 35072, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
-+ { 35094, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
-+ { 35116, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
-+ { 35136, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
-+ { 35157, 0x00001401 }, /* GL_UNSIGNED_BYTE */
-+ { 35174, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-+ { 35201, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
-+ { 35224, 0x00001405 }, /* GL_UNSIGNED_INT */
-+ { 35240, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
-+ { 35267, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
-+ { 35291, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-+ { 35322, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
-+ { 35346, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-+ { 35374, 0x00001403 }, /* GL_UNSIGNED_SHORT */
-+ { 35392, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-+ { 35422, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-+ { 35448, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-+ { 35478, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-+ { 35504, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
-+ { 35528, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-+ { 35556, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-+ { 35584, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
-+ { 35611, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-+ { 35643, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
-+ { 35674, 0x00008CA2 }, /* GL_UPPER_LEFT */
-+ { 35688, 0x00002A20 }, /* GL_V2F */
-+ { 35695, 0x00002A21 }, /* GL_V3F */
-+ { 35702, 0x00008B83 }, /* GL_VALIDATE_STATUS */
-+ { 35721, 0x00001F00 }, /* GL_VENDOR */
-+ { 35731, 0x00001F02 }, /* GL_VERSION */
-+ { 35742, 0x00008074 }, /* GL_VERTEX_ARRAY */
-+ { 35758, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-+ { 35788, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-+ { 35819, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
-+ { 35854, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
-+ { 35878, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
-+ { 35899, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
-+ { 35922, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
-+ { 35943, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-+ { 35970, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-+ { 35998, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-+ { 36026, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-+ { 36054, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-+ { 36082, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-+ { 36110, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-+ { 36138, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-+ { 36165, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-+ { 36192, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-+ { 36219, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-+ { 36246, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-+ { 36273, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-+ { 36300, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-+ { 36327, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-+ { 36354, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-+ { 36381, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-+ { 36419, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
-+ { 36461, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-+ { 36492, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-+ { 36527, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-+ { 36561, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
-+ { 36599, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-+ { 36630, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-+ { 36665, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-+ { 36693, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-+ { 36725, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-+ { 36755, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-+ { 36789, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-+ { 36817, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
-+ { 36849, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
-+ { 36869, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
-+ { 36891, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
-+ { 36920, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
-+ { 36941, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-+ { 36970, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-+ { 37003, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
-+ { 37035, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-+ { 37062, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-+ { 37093, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-+ { 37123, 0x00008B31 }, /* GL_VERTEX_SHADER */
-+ { 37140, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
-+ { 37161, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
-+ { 37188, 0x00000BA2 }, /* GL_VIEWPORT */
-+ { 37200, 0x00000800 }, /* GL_VIEWPORT_BIT */
-+ { 37216, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
-+ { 37236, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-+ { 37267, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
-+ { 37302, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-+ { 37330, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-+ { 37355, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-+ { 37382, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-+ { 37407, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
-+ { 37431, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
-+ { 37450, 0x000088B9 }, /* GL_WRITE_ONLY */
-+ { 37464, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
-+ { 37482, 0x00001506 }, /* GL_XOR */
-+ { 37489, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
-+ { 37508, 0x00008757 }, /* GL_YCBCR_MESA */
-+ { 37522, 0x00000000 }, /* GL_ZERO */
-+ { 37530, 0x00000D16 }, /* GL_ZOOM_X */
-+ { 37540, 0x00000D17 }, /* GL_ZOOM_Y */
-+};
-+
-+static const unsigned reduced_enums[1284] =
-+{
-+ 436, /* GL_FALSE */
-+ 645, /* GL_LINES */
-+ 647, /* GL_LINE_LOOP */
-+ 654, /* GL_LINE_STRIP */
-+ 1637, /* GL_TRIANGLES */
-+ 1640, /* GL_TRIANGLE_STRIP */
-+ 1638, /* GL_TRIANGLE_FAN */
-+ 1211, /* GL_QUADS */
-+ 1213, /* GL_QUAD_STRIP */
-+ 1099, /* GL_POLYGON */
-+ 1111, /* GL_POLYGON_STIPPLE_BIT */
-+ 1064, /* GL_PIXEL_MODE_BIT */
-+ 632, /* GL_LIGHTING_BIT */
-+ 458, /* GL_FOG_BIT */
-+ 8, /* GL_ACCUM */
-+ 664, /* GL_LOAD */
-+ 1253, /* GL_RETURN */
-+ 937, /* GL_MULT */
-+ 23, /* GL_ADD */
-+ 953, /* GL_NEVER */
-+ 622, /* GL_LESS */
-+ 426, /* GL_EQUAL */
-+ 621, /* GL_LEQUAL */
-+ 547, /* GL_GREATER */
-+ 968, /* GL_NOTEQUAL */
-+ 522, /* GL_GEQUAL */
-+ 46, /* GL_ALWAYS */
-+ 1386, /* GL_SRC_COLOR */
-+ 997, /* GL_ONE_MINUS_SRC_COLOR */
-+ 1384, /* GL_SRC_ALPHA */
-+ 996, /* GL_ONE_MINUS_SRC_ALPHA */
-+ 406, /* GL_DST_ALPHA */
-+ 994, /* GL_ONE_MINUS_DST_ALPHA */
-+ 407, /* GL_DST_COLOR */
-+ 995, /* GL_ONE_MINUS_DST_COLOR */
-+ 1385, /* GL_SRC_ALPHA_SATURATE */
-+ 510, /* GL_FRONT_LEFT */
-+ 511, /* GL_FRONT_RIGHT */
-+ 69, /* GL_BACK_LEFT */
-+ 70, /* GL_BACK_RIGHT */
-+ 507, /* GL_FRONT */
-+ 68, /* GL_BACK */
-+ 620, /* GL_LEFT */
-+ 1293, /* GL_RIGHT */
-+ 508, /* GL_FRONT_AND_BACK */
-+ 63, /* GL_AUX0 */
-+ 64, /* GL_AUX1 */
-+ 65, /* GL_AUX2 */
-+ 66, /* GL_AUX3 */
-+ 612, /* GL_INVALID_ENUM */
-+ 615, /* GL_INVALID_VALUE */
-+ 614, /* GL_INVALID_OPERATION */
-+ 1387, /* GL_STACK_OVERFLOW */
-+ 1388, /* GL_STACK_UNDERFLOW */
-+ 1022, /* GL_OUT_OF_MEMORY */
-+ 613, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-+ 0, /* GL_2D */
-+ 2, /* GL_3D */
-+ 3, /* GL_3D_COLOR */
-+ 4, /* GL_3D_COLOR_TEXTURE */
-+ 6, /* GL_4D_COLOR_TEXTURE */
-+ 1042, /* GL_PASS_THROUGH_TOKEN */
-+ 1098, /* GL_POINT_TOKEN */
-+ 655, /* GL_LINE_TOKEN */
-+ 1112, /* GL_POLYGON_TOKEN */
-+ 74, /* GL_BITMAP_TOKEN */
-+ 405, /* GL_DRAW_PIXEL_TOKEN */
-+ 271, /* GL_COPY_PIXEL_TOKEN */
-+ 648, /* GL_LINE_RESET_TOKEN */
-+ 429, /* GL_EXP */
-+ 430, /* GL_EXP2 */
-+ 304, /* GL_CW */
-+ 116, /* GL_CCW */
-+ 137, /* GL_COEFF */
-+ 1019, /* GL_ORDER */
-+ 344, /* GL_DOMAIN */
-+ 279, /* GL_CURRENT_COLOR */
-+ 282, /* GL_CURRENT_INDEX */
-+ 288, /* GL_CURRENT_NORMAL */
-+ 300, /* GL_CURRENT_TEXTURE_COORDS */
-+ 293, /* GL_CURRENT_RASTER_COLOR */
-+ 295, /* GL_CURRENT_RASTER_INDEX */
-+ 298, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
-+ 296, /* GL_CURRENT_RASTER_POSITION */
-+ 297, /* GL_CURRENT_RASTER_POSITION_VALID */
-+ 294, /* GL_CURRENT_RASTER_DISTANCE */
-+ 1091, /* GL_POINT_SMOOTH */
-+ 1080, /* GL_POINT_SIZE */
-+ 1090, /* GL_POINT_SIZE_RANGE */
-+ 1081, /* GL_POINT_SIZE_GRANULARITY */
-+ 649, /* GL_LINE_SMOOTH */
-+ 656, /* GL_LINE_WIDTH */
-+ 658, /* GL_LINE_WIDTH_RANGE */
-+ 657, /* GL_LINE_WIDTH_GRANULARITY */
-+ 651, /* GL_LINE_STIPPLE */
-+ 652, /* GL_LINE_STIPPLE_PATTERN */
-+ 653, /* GL_LINE_STIPPLE_REPEAT */
-+ 663, /* GL_LIST_MODE */
-+ 822, /* GL_MAX_LIST_NESTING */
-+ 660, /* GL_LIST_BASE */
-+ 662, /* GL_LIST_INDEX */
-+ 1101, /* GL_POLYGON_MODE */
-+ 1108, /* GL_POLYGON_SMOOTH */
-+ 1110, /* GL_POLYGON_STIPPLE */
-+ 414, /* GL_EDGE_FLAG */
-+ 272, /* GL_CULL_FACE */
-+ 273, /* GL_CULL_FACE_MODE */
-+ 509, /* GL_FRONT_FACE */
-+ 631, /* GL_LIGHTING */
-+ 636, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-+ 637, /* GL_LIGHT_MODEL_TWO_SIDE */
-+ 633, /* GL_LIGHT_MODEL_AMBIENT */
-+ 1339, /* GL_SHADE_MODEL */
-+ 168, /* GL_COLOR_MATERIAL_FACE */
-+ 169, /* GL_COLOR_MATERIAL_PARAMETER */
-+ 167, /* GL_COLOR_MATERIAL */
-+ 457, /* GL_FOG */
-+ 479, /* GL_FOG_INDEX */
-+ 475, /* GL_FOG_DENSITY */
-+ 483, /* GL_FOG_START */
-+ 477, /* GL_FOG_END */
-+ 480, /* GL_FOG_MODE */
-+ 459, /* GL_FOG_COLOR */
-+ 333, /* GL_DEPTH_RANGE */
-+ 338, /* GL_DEPTH_TEST */
-+ 341, /* GL_DEPTH_WRITEMASK */
-+ 321, /* GL_DEPTH_CLEAR_VALUE */
-+ 332, /* GL_DEPTH_FUNC */
-+ 12, /* GL_ACCUM_CLEAR_VALUE */
-+ 1418, /* GL_STENCIL_TEST */
-+ 1406, /* GL_STENCIL_CLEAR_VALUE */
-+ 1408, /* GL_STENCIL_FUNC */
-+ 1420, /* GL_STENCIL_VALUE_MASK */
-+ 1407, /* GL_STENCIL_FAIL */
-+ 1415, /* GL_STENCIL_PASS_DEPTH_FAIL */
-+ 1416, /* GL_STENCIL_PASS_DEPTH_PASS */
-+ 1417, /* GL_STENCIL_REF */
-+ 1421, /* GL_STENCIL_WRITEMASK */
-+ 791, /* GL_MATRIX_MODE */
-+ 958, /* GL_NORMALIZE */
-+ 1727, /* GL_VIEWPORT */
-+ 932, /* GL_MODELVIEW_STACK_DEPTH */
-+ 1191, /* GL_PROJECTION_STACK_DEPTH */
-+ 1616, /* GL_TEXTURE_STACK_DEPTH */
-+ 930, /* GL_MODELVIEW_MATRIX */
-+ 1190, /* GL_PROJECTION_MATRIX */
-+ 1601, /* GL_TEXTURE_MATRIX */
-+ 61, /* GL_ATTRIB_STACK_DEPTH */
-+ 127, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
-+ 43, /* GL_ALPHA_TEST */
-+ 44, /* GL_ALPHA_TEST_FUNC */
-+ 45, /* GL_ALPHA_TEST_REF */
-+ 343, /* GL_DITHER */
-+ 78, /* GL_BLEND_DST */
-+ 86, /* GL_BLEND_SRC */
-+ 75, /* GL_BLEND */
-+ 666, /* GL_LOGIC_OP_MODE */
-+ 586, /* GL_INDEX_LOGIC_OP */
-+ 166, /* GL_COLOR_LOGIC_OP */
-+ 67, /* GL_AUX_BUFFERS */
-+ 354, /* GL_DRAW_BUFFER */
-+ 1223, /* GL_READ_BUFFER */
-+ 1320, /* GL_SCISSOR_BOX */
-+ 1321, /* GL_SCISSOR_TEST */
-+ 585, /* GL_INDEX_CLEAR_VALUE */
-+ 590, /* GL_INDEX_WRITEMASK */
-+ 163, /* GL_COLOR_CLEAR_VALUE */
-+ 205, /* GL_COLOR_WRITEMASK */
-+ 587, /* GL_INDEX_MODE */
-+ 1287, /* GL_RGBA_MODE */
-+ 353, /* GL_DOUBLEBUFFER */
-+ 1422, /* GL_STEREO */
-+ 1246, /* GL_RENDER_MODE */
-+ 1043, /* GL_PERSPECTIVE_CORRECTION_HINT */
-+ 1092, /* GL_POINT_SMOOTH_HINT */
-+ 650, /* GL_LINE_SMOOTH_HINT */
-+ 1109, /* GL_POLYGON_SMOOTH_HINT */
-+ 478, /* GL_FOG_HINT */
-+ 1582, /* GL_TEXTURE_GEN_S */
-+ 1583, /* GL_TEXTURE_GEN_T */
-+ 1581, /* GL_TEXTURE_GEN_R */
-+ 1580, /* GL_TEXTURE_GEN_Q */
-+ 1056, /* GL_PIXEL_MAP_I_TO_I */
-+ 1062, /* GL_PIXEL_MAP_S_TO_S */
-+ 1058, /* GL_PIXEL_MAP_I_TO_R */
-+ 1054, /* GL_PIXEL_MAP_I_TO_G */
-+ 1052, /* GL_PIXEL_MAP_I_TO_B */
-+ 1050, /* GL_PIXEL_MAP_I_TO_A */
-+ 1060, /* GL_PIXEL_MAP_R_TO_R */
-+ 1048, /* GL_PIXEL_MAP_G_TO_G */
-+ 1046, /* GL_PIXEL_MAP_B_TO_B */
-+ 1044, /* GL_PIXEL_MAP_A_TO_A */
-+ 1057, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-+ 1063, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-+ 1059, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-+ 1055, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-+ 1053, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-+ 1051, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-+ 1061, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-+ 1049, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-+ 1047, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-+ 1045, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-+ 1649, /* GL_UNPACK_SWAP_BYTES */
-+ 1644, /* GL_UNPACK_LSB_FIRST */
-+ 1645, /* GL_UNPACK_ROW_LENGTH */
-+ 1648, /* GL_UNPACK_SKIP_ROWS */
-+ 1647, /* GL_UNPACK_SKIP_PIXELS */
-+ 1642, /* GL_UNPACK_ALIGNMENT */
-+ 1031, /* GL_PACK_SWAP_BYTES */
-+ 1026, /* GL_PACK_LSB_FIRST */
-+ 1027, /* GL_PACK_ROW_LENGTH */
-+ 1030, /* GL_PACK_SKIP_ROWS */
-+ 1029, /* GL_PACK_SKIP_PIXELS */
-+ 1023, /* GL_PACK_ALIGNMENT */
-+ 744, /* GL_MAP_COLOR */
-+ 745, /* GL_MAP_STENCIL */
-+ 589, /* GL_INDEX_SHIFT */
-+ 588, /* GL_INDEX_OFFSET */
-+ 1235, /* GL_RED_SCALE */
-+ 1233, /* GL_RED_BIAS */
-+ 1744, /* GL_ZOOM_X */
-+ 1745, /* GL_ZOOM_Y */
-+ 551, /* GL_GREEN_SCALE */
-+ 549, /* GL_GREEN_BIAS */
-+ 92, /* GL_BLUE_SCALE */
-+ 90, /* GL_BLUE_BIAS */
-+ 42, /* GL_ALPHA_SCALE */
-+ 40, /* GL_ALPHA_BIAS */
-+ 334, /* GL_DEPTH_SCALE */
-+ 315, /* GL_DEPTH_BIAS */
-+ 817, /* GL_MAX_EVAL_ORDER */
-+ 821, /* GL_MAX_LIGHTS */
-+ 800, /* GL_MAX_CLIP_PLANES */
-+ 865, /* GL_MAX_TEXTURE_SIZE */
-+ 827, /* GL_MAX_PIXEL_MAP_TABLE */
-+ 796, /* GL_MAX_ATTRIB_STACK_DEPTH */
-+ 824, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-+ 825, /* GL_MAX_NAME_STACK_DEPTH */
-+ 853, /* GL_MAX_PROJECTION_STACK_DEPTH */
-+ 866, /* GL_MAX_TEXTURE_STACK_DEPTH */
-+ 880, /* GL_MAX_VIEWPORT_DIMS */
-+ 797, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-+ 1429, /* GL_SUBPIXEL_BITS */
-+ 584, /* GL_INDEX_BITS */
-+ 1234, /* GL_RED_BITS */
-+ 550, /* GL_GREEN_BITS */
-+ 91, /* GL_BLUE_BITS */
-+ 41, /* GL_ALPHA_BITS */
-+ 316, /* GL_DEPTH_BITS */
-+ 1404, /* GL_STENCIL_BITS */
-+ 14, /* GL_ACCUM_RED_BITS */
-+ 13, /* GL_ACCUM_GREEN_BITS */
-+ 10, /* GL_ACCUM_BLUE_BITS */
-+ 9, /* GL_ACCUM_ALPHA_BITS */
-+ 946, /* GL_NAME_STACK_DEPTH */
-+ 62, /* GL_AUTO_NORMAL */
-+ 690, /* GL_MAP1_COLOR_4 */
-+ 693, /* GL_MAP1_INDEX */
-+ 694, /* GL_MAP1_NORMAL */
-+ 695, /* GL_MAP1_TEXTURE_COORD_1 */
-+ 696, /* GL_MAP1_TEXTURE_COORD_2 */
-+ 697, /* GL_MAP1_TEXTURE_COORD_3 */
-+ 698, /* GL_MAP1_TEXTURE_COORD_4 */
-+ 699, /* GL_MAP1_VERTEX_3 */
-+ 700, /* GL_MAP1_VERTEX_4 */
-+ 717, /* GL_MAP2_COLOR_4 */
-+ 720, /* GL_MAP2_INDEX */
-+ 721, /* GL_MAP2_NORMAL */
-+ 722, /* GL_MAP2_TEXTURE_COORD_1 */
-+ 723, /* GL_MAP2_TEXTURE_COORD_2 */
-+ 724, /* GL_MAP2_TEXTURE_COORD_3 */
-+ 725, /* GL_MAP2_TEXTURE_COORD_4 */
-+ 726, /* GL_MAP2_VERTEX_3 */
-+ 727, /* GL_MAP2_VERTEX_4 */
-+ 691, /* GL_MAP1_GRID_DOMAIN */
-+ 692, /* GL_MAP1_GRID_SEGMENTS */
-+ 718, /* GL_MAP2_GRID_DOMAIN */
-+ 719, /* GL_MAP2_GRID_SEGMENTS */
-+ 1506, /* GL_TEXTURE_1D */
-+ 1508, /* GL_TEXTURE_2D */
-+ 439, /* GL_FEEDBACK_BUFFER_POINTER */
-+ 440, /* GL_FEEDBACK_BUFFER_SIZE */
-+ 441, /* GL_FEEDBACK_BUFFER_TYPE */
-+ 1330, /* GL_SELECTION_BUFFER_POINTER */
-+ 1331, /* GL_SELECTION_BUFFER_SIZE */
-+ 1619, /* GL_TEXTURE_WIDTH */
-+ 1587, /* GL_TEXTURE_HEIGHT */
-+ 1543, /* GL_TEXTURE_COMPONENTS */
-+ 1527, /* GL_TEXTURE_BORDER_COLOR */
-+ 1526, /* GL_TEXTURE_BORDER */
-+ 345, /* GL_DONT_CARE */
-+ 437, /* GL_FASTEST */
-+ 954, /* GL_NICEST */
-+ 47, /* GL_AMBIENT */
-+ 342, /* GL_DIFFUSE */
-+ 1373, /* GL_SPECULAR */
-+ 1113, /* GL_POSITION */
-+ 1376, /* GL_SPOT_DIRECTION */
-+ 1377, /* GL_SPOT_EXPONENT */
-+ 1375, /* GL_SPOT_CUTOFF */
-+ 245, /* GL_CONSTANT_ATTENUATION */
-+ 640, /* GL_LINEAR_ATTENUATION */
-+ 1210, /* GL_QUADRATIC_ATTENUATION */
-+ 219, /* GL_COMPILE */
-+ 220, /* GL_COMPILE_AND_EXECUTE */
-+ 111, /* GL_BYTE */
-+ 1650, /* GL_UNSIGNED_BYTE */
-+ 1344, /* GL_SHORT */
-+ 1659, /* GL_UNSIGNED_SHORT */
-+ 592, /* GL_INT */
-+ 1653, /* GL_UNSIGNED_INT */
-+ 444, /* GL_FLOAT */
-+ 1, /* GL_2_BYTES */
-+ 5, /* GL_3_BYTES */
-+ 7, /* GL_4_BYTES */
-+ 352, /* GL_DOUBLE */
-+ 123, /* GL_CLEAR */
-+ 49, /* GL_AND */
-+ 51, /* GL_AND_REVERSE */
-+ 269, /* GL_COPY */
-+ 50, /* GL_AND_INVERTED */
-+ 956, /* GL_NOOP */
-+ 1740, /* GL_XOR */
-+ 1018, /* GL_OR */
-+ 957, /* GL_NOR */
-+ 427, /* GL_EQUIV */
-+ 618, /* GL_INVERT */
-+ 1021, /* GL_OR_REVERSE */
-+ 270, /* GL_COPY_INVERTED */
-+ 1020, /* GL_OR_INVERTED */
-+ 947, /* GL_NAND */
-+ 1335, /* GL_SET */
-+ 424, /* GL_EMISSION */
-+ 1343, /* GL_SHININESS */
-+ 48, /* GL_AMBIENT_AND_DIFFUSE */
-+ 165, /* GL_COLOR_INDEXES */
-+ 897, /* GL_MODELVIEW */
-+ 1189, /* GL_PROJECTION */
-+ 1441, /* GL_TEXTURE */
-+ 138, /* GL_COLOR */
-+ 313, /* GL_DEPTH */
-+ 1395, /* GL_STENCIL */
-+ 164, /* GL_COLOR_INDEX */
-+ 1409, /* GL_STENCIL_INDEX */
-+ 322, /* GL_DEPTH_COMPONENT */
-+ 1230, /* GL_RED */
-+ 548, /* GL_GREEN */
-+ 89, /* GL_BLUE */
-+ 31, /* GL_ALPHA */
-+ 1254, /* GL_RGB */
-+ 1273, /* GL_RGBA */
-+ 668, /* GL_LUMINANCE */
-+ 689, /* GL_LUMINANCE_ALPHA */
-+ 73, /* GL_BITMAP */
-+ 1069, /* GL_POINT */
-+ 638, /* GL_LINE */
-+ 442, /* GL_FILL */
-+ 1239, /* GL_RENDER */
-+ 438, /* GL_FEEDBACK */
-+ 1329, /* GL_SELECT */
-+ 443, /* GL_FLAT */
-+ 1348, /* GL_SMOOTH */
-+ 619, /* GL_KEEP */
-+ 1248, /* GL_REPLACE */
-+ 575, /* GL_INCR */
-+ 309, /* GL_DECR */
-+ 1674, /* GL_VENDOR */
-+ 1245, /* GL_RENDERER */
-+ 1675, /* GL_VERSION */
-+ 431, /* GL_EXTENSIONS */
-+ 1294, /* GL_S */
-+ 1432, /* GL_T */
-+ 1220, /* GL_R */
-+ 1209, /* GL_Q */
-+ 933, /* GL_MODULATE */
-+ 308, /* GL_DECAL */
-+ 1577, /* GL_TEXTURE_ENV_MODE */
-+ 1576, /* GL_TEXTURE_ENV_COLOR */
-+ 1575, /* GL_TEXTURE_ENV */
-+ 432, /* GL_EYE_LINEAR */
-+ 980, /* GL_OBJECT_LINEAR */
-+ 1374, /* GL_SPHERE_MAP */
-+ 1579, /* GL_TEXTURE_GEN_MODE */
-+ 982, /* GL_OBJECT_PLANE */
-+ 433, /* GL_EYE_PLANE */
-+ 948, /* GL_NEAREST */
-+ 639, /* GL_LINEAR */
-+ 952, /* GL_NEAREST_MIPMAP_NEAREST */
-+ 644, /* GL_LINEAR_MIPMAP_NEAREST */
-+ 951, /* GL_NEAREST_MIPMAP_LINEAR */
-+ 643, /* GL_LINEAR_MIPMAP_LINEAR */
-+ 1600, /* GL_TEXTURE_MAG_FILTER */
-+ 1608, /* GL_TEXTURE_MIN_FILTER */
-+ 1621, /* GL_TEXTURE_WRAP_S */
-+ 1622, /* GL_TEXTURE_WRAP_T */
-+ 117, /* GL_CLAMP */
-+ 1247, /* GL_REPEAT */
-+ 1107, /* GL_POLYGON_OFFSET_UNITS */
-+ 1106, /* GL_POLYGON_OFFSET_POINT */
-+ 1105, /* GL_POLYGON_OFFSET_LINE */
-+ 1221, /* GL_R3_G3_B2 */
-+ 1671, /* GL_V2F */
-+ 1672, /* GL_V3F */
-+ 114, /* GL_C4UB_V2F */
-+ 115, /* GL_C4UB_V3F */
-+ 112, /* GL_C3F_V3F */
-+ 945, /* GL_N3F_V3F */
-+ 113, /* GL_C4F_N3F_V3F */
-+ 1437, /* GL_T2F_V3F */
-+ 1439, /* GL_T4F_V4F */
-+ 1435, /* GL_T2F_C4UB_V3F */
-+ 1433, /* GL_T2F_C3F_V3F */
-+ 1436, /* GL_T2F_N3F_V3F */
-+ 1434, /* GL_T2F_C4F_N3F_V3F */
-+ 1438, /* GL_T4F_C4F_N3F_V4F */
-+ 130, /* GL_CLIP_PLANE0 */
-+ 131, /* GL_CLIP_PLANE1 */
-+ 132, /* GL_CLIP_PLANE2 */
-+ 133, /* GL_CLIP_PLANE3 */
-+ 134, /* GL_CLIP_PLANE4 */
-+ 135, /* GL_CLIP_PLANE5 */
-+ 623, /* GL_LIGHT0 */
-+ 624, /* GL_LIGHT1 */
-+ 625, /* GL_LIGHT2 */
-+ 626, /* GL_LIGHT3 */
-+ 627, /* GL_LIGHT4 */
-+ 628, /* GL_LIGHT5 */
-+ 629, /* GL_LIGHT6 */
-+ 630, /* GL_LIGHT7 */
-+ 552, /* GL_HINT_BIT */
-+ 247, /* GL_CONSTANT_COLOR */
-+ 992, /* GL_ONE_MINUS_CONSTANT_COLOR */
-+ 242, /* GL_CONSTANT_ALPHA */
-+ 990, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-+ 76, /* GL_BLEND_COLOR */
-+ 512, /* GL_FUNC_ADD */
-+ 881, /* GL_MIN */
-+ 793, /* GL_MAX */
-+ 81, /* GL_BLEND_EQUATION */
-+ 516, /* GL_FUNC_SUBTRACT */
-+ 514, /* GL_FUNC_REVERSE_SUBTRACT */
-+ 250, /* GL_CONVOLUTION_1D */
-+ 251, /* GL_CONVOLUTION_2D */
-+ 1332, /* GL_SEPARABLE_2D */
-+ 254, /* GL_CONVOLUTION_BORDER_MODE */
-+ 258, /* GL_CONVOLUTION_FILTER_SCALE */
-+ 256, /* GL_CONVOLUTION_FILTER_BIAS */
-+ 1231, /* GL_REDUCE */
-+ 260, /* GL_CONVOLUTION_FORMAT */
-+ 264, /* GL_CONVOLUTION_WIDTH */
-+ 262, /* GL_CONVOLUTION_HEIGHT */
-+ 808, /* GL_MAX_CONVOLUTION_WIDTH */
-+ 806, /* GL_MAX_CONVOLUTION_HEIGHT */
-+ 1146, /* GL_POST_CONVOLUTION_RED_SCALE */
-+ 1142, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-+ 1137, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-+ 1133, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-+ 1144, /* GL_POST_CONVOLUTION_RED_BIAS */
-+ 1140, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-+ 1135, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-+ 1131, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-+ 553, /* GL_HISTOGRAM */
-+ 1193, /* GL_PROXY_HISTOGRAM */
-+ 569, /* GL_HISTOGRAM_WIDTH */
-+ 559, /* GL_HISTOGRAM_FORMAT */
-+ 565, /* GL_HISTOGRAM_RED_SIZE */
-+ 561, /* GL_HISTOGRAM_GREEN_SIZE */
-+ 556, /* GL_HISTOGRAM_BLUE_SIZE */
-+ 554, /* GL_HISTOGRAM_ALPHA_SIZE */
-+ 563, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-+ 567, /* GL_HISTOGRAM_SINK */
-+ 882, /* GL_MINMAX */
-+ 884, /* GL_MINMAX_FORMAT */
-+ 886, /* GL_MINMAX_SINK */
-+ 1440, /* GL_TABLE_TOO_LARGE_EXT */
-+ 1652, /* GL_UNSIGNED_BYTE_3_3_2 */
-+ 1661, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-+ 1663, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-+ 1657, /* GL_UNSIGNED_INT_8_8_8_8 */
-+ 1654, /* GL_UNSIGNED_INT_10_10_10_2 */
-+ 1104, /* GL_POLYGON_OFFSET_FILL */
-+ 1103, /* GL_POLYGON_OFFSET_FACTOR */
-+ 1102, /* GL_POLYGON_OFFSET_BIAS */
-+ 1251, /* GL_RESCALE_NORMAL */
-+ 36, /* GL_ALPHA4 */
-+ 38, /* GL_ALPHA8 */
-+ 32, /* GL_ALPHA12 */
-+ 34, /* GL_ALPHA16 */
-+ 679, /* GL_LUMINANCE4 */
-+ 685, /* GL_LUMINANCE8 */
-+ 669, /* GL_LUMINANCE12 */
-+ 675, /* GL_LUMINANCE16 */
-+ 680, /* GL_LUMINANCE4_ALPHA4 */
-+ 683, /* GL_LUMINANCE6_ALPHA2 */
-+ 686, /* GL_LUMINANCE8_ALPHA8 */
-+ 672, /* GL_LUMINANCE12_ALPHA4 */
-+ 670, /* GL_LUMINANCE12_ALPHA12 */
-+ 676, /* GL_LUMINANCE16_ALPHA16 */
-+ 593, /* GL_INTENSITY */
-+ 598, /* GL_INTENSITY4 */
-+ 600, /* GL_INTENSITY8 */
-+ 594, /* GL_INTENSITY12 */
-+ 596, /* GL_INTENSITY16 */
-+ 1263, /* GL_RGB2_EXT */
-+ 1264, /* GL_RGB4 */
-+ 1267, /* GL_RGB5 */
-+ 1271, /* GL_RGB8 */
-+ 1255, /* GL_RGB10 */
-+ 1259, /* GL_RGB12 */
-+ 1261, /* GL_RGB16 */
-+ 1278, /* GL_RGBA2 */
-+ 1280, /* GL_RGBA4 */
-+ 1268, /* GL_RGB5_A1 */
-+ 1284, /* GL_RGBA8 */
-+ 1256, /* GL_RGB10_A2 */
-+ 1274, /* GL_RGBA12 */
-+ 1276, /* GL_RGBA16 */
-+ 1613, /* GL_TEXTURE_RED_SIZE */
-+ 1585, /* GL_TEXTURE_GREEN_SIZE */
-+ 1524, /* GL_TEXTURE_BLUE_SIZE */
-+ 1511, /* GL_TEXTURE_ALPHA_SIZE */
-+ 1598, /* GL_TEXTURE_LUMINANCE_SIZE */
-+ 1589, /* GL_TEXTURE_INTENSITY_SIZE */
-+ 1249, /* GL_REPLACE_EXT */
-+ 1197, /* GL_PROXY_TEXTURE_1D */
-+ 1200, /* GL_PROXY_TEXTURE_2D */
-+ 1617, /* GL_TEXTURE_TOO_LARGE_EXT */
-+ 1610, /* GL_TEXTURE_PRIORITY */
-+ 1615, /* GL_TEXTURE_RESIDENT */
-+ 1514, /* GL_TEXTURE_BINDING_1D */
-+ 1516, /* GL_TEXTURE_BINDING_2D */
-+ 1518, /* GL_TEXTURE_BINDING_3D */
-+ 1028, /* GL_PACK_SKIP_IMAGES */
-+ 1024, /* GL_PACK_IMAGE_HEIGHT */
-+ 1646, /* GL_UNPACK_SKIP_IMAGES */
-+ 1643, /* GL_UNPACK_IMAGE_HEIGHT */
-+ 1510, /* GL_TEXTURE_3D */
-+ 1203, /* GL_PROXY_TEXTURE_3D */
-+ 1572, /* GL_TEXTURE_DEPTH */
-+ 1620, /* GL_TEXTURE_WRAP_R */
-+ 794, /* GL_MAX_3D_TEXTURE_SIZE */
-+ 1676, /* GL_VERTEX_ARRAY */
-+ 959, /* GL_NORMAL_ARRAY */
-+ 139, /* GL_COLOR_ARRAY */
-+ 578, /* GL_INDEX_ARRAY */
-+ 1551, /* GL_TEXTURE_COORD_ARRAY */
-+ 415, /* GL_EDGE_FLAG_ARRAY */
-+ 1681, /* GL_VERTEX_ARRAY_SIZE */
-+ 1683, /* GL_VERTEX_ARRAY_TYPE */
-+ 1682, /* GL_VERTEX_ARRAY_STRIDE */
-+ 964, /* GL_NORMAL_ARRAY_TYPE */
-+ 963, /* GL_NORMAL_ARRAY_STRIDE */
-+ 143, /* GL_COLOR_ARRAY_SIZE */
-+ 145, /* GL_COLOR_ARRAY_TYPE */
-+ 144, /* GL_COLOR_ARRAY_STRIDE */
-+ 583, /* GL_INDEX_ARRAY_TYPE */
-+ 582, /* GL_INDEX_ARRAY_STRIDE */
-+ 1555, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-+ 1557, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-+ 1556, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-+ 419, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-+ 1680, /* GL_VERTEX_ARRAY_POINTER */
-+ 962, /* GL_NORMAL_ARRAY_POINTER */
-+ 142, /* GL_COLOR_ARRAY_POINTER */
-+ 581, /* GL_INDEX_ARRAY_POINTER */
-+ 1554, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-+ 418, /* GL_EDGE_FLAG_ARRAY_POINTER */
-+ 938, /* GL_MULTISAMPLE */
-+ 1306, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-+ 1308, /* GL_SAMPLE_ALPHA_TO_ONE */
-+ 1313, /* GL_SAMPLE_COVERAGE */
-+ 1310, /* GL_SAMPLE_BUFFERS */
-+ 1301, /* GL_SAMPLES */
-+ 1317, /* GL_SAMPLE_COVERAGE_VALUE */
-+ 1315, /* GL_SAMPLE_COVERAGE_INVERT */
-+ 170, /* GL_COLOR_MATRIX */
-+ 172, /* GL_COLOR_MATRIX_STACK_DEPTH */
-+ 802, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-+ 1129, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-+ 1125, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-+ 1120, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-+ 1116, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-+ 1127, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-+ 1123, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-+ 1118, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-+ 1114, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-+ 1534, /* GL_TEXTURE_COLOR_TABLE_SGI */
-+ 1204, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-+ 1536, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-+ 80, /* GL_BLEND_DST_RGB */
-+ 88, /* GL_BLEND_SRC_RGB */
-+ 79, /* GL_BLEND_DST_ALPHA */
-+ 87, /* GL_BLEND_SRC_ALPHA */
-+ 176, /* GL_COLOR_TABLE */
-+ 1139, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-+ 1122, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-+ 1192, /* GL_PROXY_COLOR_TABLE */
-+ 1196, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-+ 1195, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-+ 200, /* GL_COLOR_TABLE_SCALE */
-+ 180, /* GL_COLOR_TABLE_BIAS */
-+ 185, /* GL_COLOR_TABLE_FORMAT */
-+ 202, /* GL_COLOR_TABLE_WIDTH */
-+ 197, /* GL_COLOR_TABLE_RED_SIZE */
-+ 188, /* GL_COLOR_TABLE_GREEN_SIZE */
-+ 182, /* GL_COLOR_TABLE_BLUE_SIZE */
-+ 177, /* GL_COLOR_TABLE_ALPHA_SIZE */
-+ 194, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
-+ 191, /* GL_COLOR_TABLE_INTENSITY_SIZE */
-+ 71, /* GL_BGR */
-+ 72, /* GL_BGRA */
-+ 816, /* GL_MAX_ELEMENTS_VERTICES */
-+ 815, /* GL_MAX_ELEMENTS_INDICES */
-+ 1588, /* GL_TEXTURE_INDEX_SIZE_EXT */
-+ 136, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-+ 1086, /* GL_POINT_SIZE_MIN */
-+ 1082, /* GL_POINT_SIZE_MAX */
-+ 1076, /* GL_POINT_FADE_THRESHOLD_SIZE */
-+ 1072, /* GL_POINT_DISTANCE_ATTENUATION */
-+ 118, /* GL_CLAMP_TO_BORDER */
-+ 121, /* GL_CLAMP_TO_EDGE */
-+ 1609, /* GL_TEXTURE_MIN_LOD */
-+ 1607, /* GL_TEXTURE_MAX_LOD */
-+ 1513, /* GL_TEXTURE_BASE_LEVEL */
-+ 1606, /* GL_TEXTURE_MAX_LEVEL */
-+ 572, /* GL_IGNORE_BORDER_HP */
-+ 246, /* GL_CONSTANT_BORDER_HP */
-+ 1250, /* GL_REPLICATE_BORDER_HP */
-+ 252, /* GL_CONVOLUTION_BORDER_COLOR */
-+ 987, /* GL_OCCLUSION_TEST_HP */
-+ 988, /* GL_OCCLUSION_TEST_RESULT_HP */
-+ 641, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-+ 1528, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-+ 1530, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-+ 1532, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-+ 1533, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+ 1531, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-+ 1529, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-+ 798, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-+ 799, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+ 1149, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-+ 1151, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-+ 1148, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-+ 1150, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-+ 1596, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-+ 1597, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-+ 1595, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-+ 518, /* GL_GENERATE_MIPMAP */
-+ 519, /* GL_GENERATE_MIPMAP_HINT */
-+ 481, /* GL_FOG_OFFSET_SGIX */
-+ 482, /* GL_FOG_OFFSET_VALUE_SGIX */
-+ 1542, /* GL_TEXTURE_COMPARE_SGIX */
-+ 1541, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-+ 1592, /* GL_TEXTURE_LEQUAL_R_SGIX */
-+ 1584, /* GL_TEXTURE_GEQUAL_R_SGIX */
-+ 323, /* GL_DEPTH_COMPONENT16 */
-+ 326, /* GL_DEPTH_COMPONENT24 */
-+ 329, /* GL_DEPTH_COMPONENT32 */
-+ 274, /* GL_CULL_VERTEX_EXT */
-+ 276, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
-+ 275, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-+ 1737, /* GL_WRAP_BORDER_SUN */
-+ 1535, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-+ 634, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-+ 1345, /* GL_SINGLE_COLOR */
-+ 1333, /* GL_SEPARATE_SPECULAR_COLOR */
-+ 1342, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-+ 1651, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-+ 1664, /* GL_UNSIGNED_SHORT_5_6_5 */
-+ 1665, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-+ 1662, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-+ 1660, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-+ 1658, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-+ 1656, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-+ 1604, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-+ 1605, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-+ 1603, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-+ 889, /* GL_MIRRORED_REPEAT */
-+ 1289, /* GL_RGB_S3TC */
-+ 1266, /* GL_RGB4_S3TC */
-+ 1288, /* GL_RGBA_S3TC */
-+ 1283, /* GL_RGBA4_S3TC */
-+ 1286, /* GL_RGBA_DXT5_S3TC */
-+ 1281, /* GL_RGBA4_DXT5_S3TC */
-+ 239, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
-+ 234, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
-+ 235, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
-+ 236, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-+ 950, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-+ 949, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-+ 642, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-+ 468, /* GL_FOG_COORDINATE_SOURCE */
-+ 460, /* GL_FOG_COORD */
-+ 484, /* GL_FRAGMENT_DEPTH */
-+ 280, /* GL_CURRENT_FOG_COORD */
-+ 467, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-+ 466, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-+ 465, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-+ 462, /* GL_FOG_COORDINATE_ARRAY */
-+ 174, /* GL_COLOR_SUM */
-+ 299, /* GL_CURRENT_SECONDARY_COLOR */
-+ 1326, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-+ 1328, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-+ 1327, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-+ 1325, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-+ 1322, /* GL_SECONDARY_COLOR_ARRAY */
-+ 528, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */
-+ 28, /* GL_ALIASED_POINT_SIZE_RANGE */
-+ 27, /* GL_ALIASED_LINE_WIDTH_RANGE */
-+ 1442, /* GL_TEXTURE0 */
-+ 1444, /* GL_TEXTURE1 */
-+ 1466, /* GL_TEXTURE2 */
-+ 1488, /* GL_TEXTURE3 */
-+ 1494, /* GL_TEXTURE4 */
-+ 1496, /* GL_TEXTURE5 */
-+ 1498, /* GL_TEXTURE6 */
-+ 1500, /* GL_TEXTURE7 */
-+ 1502, /* GL_TEXTURE8 */
-+ 1504, /* GL_TEXTURE9 */
-+ 1445, /* GL_TEXTURE10 */
-+ 1447, /* GL_TEXTURE11 */
-+ 1449, /* GL_TEXTURE12 */
-+ 1451, /* GL_TEXTURE13 */
-+ 1453, /* GL_TEXTURE14 */
-+ 1455, /* GL_TEXTURE15 */
-+ 1457, /* GL_TEXTURE16 */
-+ 1459, /* GL_TEXTURE17 */
-+ 1461, /* GL_TEXTURE18 */
-+ 1463, /* GL_TEXTURE19 */
-+ 1467, /* GL_TEXTURE20 */
-+ 1469, /* GL_TEXTURE21 */
-+ 1471, /* GL_TEXTURE22 */
-+ 1473, /* GL_TEXTURE23 */
-+ 1475, /* GL_TEXTURE24 */
-+ 1477, /* GL_TEXTURE25 */
-+ 1479, /* GL_TEXTURE26 */
-+ 1481, /* GL_TEXTURE27 */
-+ 1483, /* GL_TEXTURE28 */
-+ 1485, /* GL_TEXTURE29 */
-+ 1489, /* GL_TEXTURE30 */
-+ 1491, /* GL_TEXTURE31 */
-+ 18, /* GL_ACTIVE_TEXTURE */
-+ 124, /* GL_CLIENT_ACTIVE_TEXTURE */
-+ 867, /* GL_MAX_TEXTURE_UNITS */
-+ 1630, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-+ 1633, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-+ 1635, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-+ 1627, /* GL_TRANSPOSE_COLOR_MATRIX */
-+ 1430, /* GL_SUBTRACT */
-+ 856, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-+ 222, /* GL_COMPRESSED_ALPHA */
-+ 226, /* GL_COMPRESSED_LUMINANCE */
-+ 227, /* GL_COMPRESSED_LUMINANCE_ALPHA */
-+ 224, /* GL_COMPRESSED_INTENSITY */
-+ 230, /* GL_COMPRESSED_RGB */
-+ 231, /* GL_COMPRESSED_RGBA */
-+ 1549, /* GL_TEXTURE_COMPRESSION_HINT */
-+ 1611, /* GL_TEXTURE_RECTANGLE_ARB */
-+ 1521, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-+ 1207, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-+ 854, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-+ 335, /* GL_DEPTH_STENCIL_NV */
-+ 1655, /* GL_UNSIGNED_INT_24_8_NV */
-+ 863, /* GL_MAX_TEXTURE_LOD_BIAS */
-+ 1602, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-+ 864, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-+ 1578, /* GL_TEXTURE_FILTER_CONTROL */
-+ 1593, /* GL_TEXTURE_LOD_BIAS */
-+ 207, /* GL_COMBINE4 */
-+ 857, /* GL_MAX_SHININESS_NV */
-+ 858, /* GL_MAX_SPOT_EXPONENT_NV */
-+ 576, /* GL_INCR_WRAP */
-+ 310, /* GL_DECR_WRAP */
-+ 909, /* GL_MODELVIEW1_ARB */
-+ 965, /* GL_NORMAL_MAP */
-+ 1236, /* GL_REFLECTION_MAP */
-+ 1558, /* GL_TEXTURE_CUBE_MAP */
-+ 1519, /* GL_TEXTURE_BINDING_CUBE_MAP */
-+ 1566, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-+ 1560, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-+ 1568, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-+ 1562, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-+ 1570, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-+ 1564, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-+ 1205, /* GL_PROXY_TEXTURE_CUBE_MAP */
-+ 810, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-+ 944, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-+ 476, /* GL_FOG_DISTANCE_MODE_NV */
-+ 435, /* GL_EYE_RADIAL_NV */
-+ 434, /* GL_EYE_PLANE_ABSOLUTE_NV */
-+ 206, /* GL_COMBINE */
-+ 213, /* GL_COMBINE_RGB */
-+ 208, /* GL_COMBINE_ALPHA */
-+ 1290, /* GL_RGB_SCALE */
-+ 24, /* GL_ADD_SIGNED */
-+ 603, /* GL_INTERPOLATE */
-+ 241, /* GL_CONSTANT */
-+ 1155, /* GL_PRIMARY_COLOR */
-+ 1152, /* GL_PREVIOUS */
-+ 1356, /* GL_SOURCE0_RGB */
-+ 1362, /* GL_SOURCE1_RGB */
-+ 1368, /* GL_SOURCE2_RGB */
-+ 1372, /* GL_SOURCE3_RGB_NV */
-+ 1353, /* GL_SOURCE0_ALPHA */
-+ 1359, /* GL_SOURCE1_ALPHA */
-+ 1365, /* GL_SOURCE2_ALPHA */
-+ 1371, /* GL_SOURCE3_ALPHA_NV */
-+ 1001, /* GL_OPERAND0_RGB */
-+ 1007, /* GL_OPERAND1_RGB */
-+ 1013, /* GL_OPERAND2_RGB */
-+ 1017, /* GL_OPERAND3_RGB_NV */
-+ 998, /* GL_OPERAND0_ALPHA */
-+ 1004, /* GL_OPERAND1_ALPHA */
-+ 1010, /* GL_OPERAND2_ALPHA */
-+ 1016, /* GL_OPERAND3_ALPHA_NV */
-+ 1677, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-+ 1741, /* GL_YCBCR_422_APPLE */
-+ 1666, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-+ 1668, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-+ 1347, /* GL_SLICE_ACCUM_SUN */
-+ 1212, /* GL_QUAD_MESH_SUN */
-+ 1639, /* GL_TRIANGLE_MESH_SUN */
-+ 1715, /* GL_VERTEX_PROGRAM_ARB */
-+ 1726, /* GL_VERTEX_STATE_PROGRAM_NV */
-+ 1702, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-+ 1708, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-+ 1710, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-+ 1712, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-+ 301, /* GL_CURRENT_VERTEX_ATTRIB */
-+ 1168, /* GL_PROGRAM_LENGTH_ARB */
-+ 1182, /* GL_PROGRAM_STRING_ARB */
-+ 931, /* GL_MODELVIEW_PROJECTION_NV */
-+ 571, /* GL_IDENTITY_NV */
-+ 616, /* GL_INVERSE_NV */
-+ 1632, /* GL_TRANSPOSE_NV */
-+ 617, /* GL_INVERSE_TRANSPOSE_NV */
-+ 840, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-+ 839, /* GL_MAX_PROGRAM_MATRICES_ARB */
-+ 747, /* GL_MATRIX0_NV */
-+ 759, /* GL_MATRIX1_NV */
-+ 771, /* GL_MATRIX2_NV */
-+ 775, /* GL_MATRIX3_NV */
-+ 777, /* GL_MATRIX4_NV */
-+ 779, /* GL_MATRIX5_NV */
-+ 781, /* GL_MATRIX6_NV */
-+ 783, /* GL_MATRIX7_NV */
-+ 286, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
-+ 283, /* GL_CURRENT_MATRIX_ARB */
-+ 1718, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-+ 1721, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-+ 1180, /* GL_PROGRAM_PARAMETER_NV */
-+ 1706, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-+ 1184, /* GL_PROGRAM_TARGET_NV */
-+ 1181, /* GL_PROGRAM_RESIDENT_NV */
-+ 1624, /* GL_TRACK_MATRIX_NV */
-+ 1625, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-+ 1716, /* GL_VERTEX_PROGRAM_BINDING_NV */
-+ 1162, /* GL_PROGRAM_ERROR_POSITION_ARB */
-+ 320, /* GL_DEPTH_CLAMP_NV */
-+ 1684, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-+ 1691, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-+ 1692, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-+ 1693, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-+ 1694, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-+ 1695, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-+ 1696, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-+ 1697, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-+ 1698, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-+ 1699, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-+ 1685, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-+ 1686, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-+ 1687, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-+ 1688, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-+ 1689, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-+ 1690, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-+ 701, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-+ 708, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-+ 709, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-+ 710, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-+ 711, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-+ 712, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-+ 713, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-+ 714, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-+ 715, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-+ 716, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-+ 702, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-+ 703, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-+ 704, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-+ 705, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-+ 706, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-+ 707, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-+ 728, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-+ 735, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-+ 736, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-+ 737, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-+ 738, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-+ 739, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-+ 740, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-+ 1161, /* GL_PROGRAM_BINDING_ARB */
-+ 742, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-+ 743, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-+ 729, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-+ 730, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-+ 731, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-+ 732, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-+ 733, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-+ 734, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-+ 1547, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-+ 1544, /* GL_TEXTURE_COMPRESSED */
-+ 970, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-+ 240, /* GL_COMPRESSED_TEXTURE_FORMATS */
-+ 879, /* GL_MAX_VERTEX_UNITS_ARB */
-+ 22, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-+ 1736, /* GL_WEIGHT_SUM_UNITY_ARB */
-+ 1714, /* GL_VERTEX_BLEND_ARB */
-+ 303, /* GL_CURRENT_WEIGHT_ARB */
-+ 1735, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-+ 1734, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-+ 1733, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-+ 1732, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-+ 1729, /* GL_WEIGHT_ARRAY_ARB */
-+ 346, /* GL_DOT3_RGB */
-+ 347, /* GL_DOT3_RGBA */
-+ 238, /* GL_COMPRESSED_RGB_FXT1_3DFX */
-+ 233, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-+ 939, /* GL_MULTISAMPLE_3DFX */
-+ 1311, /* GL_SAMPLE_BUFFERS_3DFX */
-+ 1302, /* GL_SAMPLES_3DFX */
-+ 920, /* GL_MODELVIEW2_ARB */
-+ 923, /* GL_MODELVIEW3_ARB */
-+ 924, /* GL_MODELVIEW4_ARB */
-+ 925, /* GL_MODELVIEW5_ARB */
-+ 926, /* GL_MODELVIEW6_ARB */
-+ 927, /* GL_MODELVIEW7_ARB */
-+ 928, /* GL_MODELVIEW8_ARB */
-+ 929, /* GL_MODELVIEW9_ARB */
-+ 899, /* GL_MODELVIEW10_ARB */
-+ 900, /* GL_MODELVIEW11_ARB */
-+ 901, /* GL_MODELVIEW12_ARB */
-+ 902, /* GL_MODELVIEW13_ARB */
-+ 903, /* GL_MODELVIEW14_ARB */
-+ 904, /* GL_MODELVIEW15_ARB */
-+ 905, /* GL_MODELVIEW16_ARB */
-+ 906, /* GL_MODELVIEW17_ARB */
-+ 907, /* GL_MODELVIEW18_ARB */
-+ 908, /* GL_MODELVIEW19_ARB */
-+ 910, /* GL_MODELVIEW20_ARB */
-+ 911, /* GL_MODELVIEW21_ARB */
-+ 912, /* GL_MODELVIEW22_ARB */
-+ 913, /* GL_MODELVIEW23_ARB */
-+ 914, /* GL_MODELVIEW24_ARB */
-+ 915, /* GL_MODELVIEW25_ARB */
-+ 916, /* GL_MODELVIEW26_ARB */
-+ 917, /* GL_MODELVIEW27_ARB */
-+ 918, /* GL_MODELVIEW28_ARB */
-+ 919, /* GL_MODELVIEW29_ARB */
-+ 921, /* GL_MODELVIEW30_ARB */
-+ 922, /* GL_MODELVIEW31_ARB */
-+ 351, /* GL_DOT3_RGB_EXT */
-+ 349, /* GL_DOT3_RGBA_EXT */
-+ 893, /* GL_MIRROR_CLAMP_EXT */
-+ 896, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-+ 934, /* GL_MODULATE_ADD_ATI */
-+ 935, /* GL_MODULATE_SIGNED_ADD_ATI */
-+ 936, /* GL_MODULATE_SUBTRACT_ATI */
-+ 1742, /* GL_YCBCR_MESA */
-+ 1025, /* GL_PACK_INVERT_MESA */
-+ 306, /* GL_DEBUG_OBJECT_MESA */
-+ 307, /* GL_DEBUG_PRINT_MESA */
-+ 305, /* GL_DEBUG_ASSERT_MESA */
-+ 107, /* GL_BUFFER_SIZE */
-+ 109, /* GL_BUFFER_USAGE */
-+ 1398, /* GL_STENCIL_BACK_FUNC */
-+ 1397, /* GL_STENCIL_BACK_FAIL */
-+ 1399, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-+ 1400, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-+ 485, /* GL_FRAGMENT_PROGRAM_ARB */
-+ 1159, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+ 1187, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+ 1186, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-+ 1171, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+ 1177, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+ 1176, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+ 829, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+ 852, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+ 851, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-+ 842, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+ 848, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+ 847, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+ 812, /* GL_MAX_DRAW_BUFFERS */
-+ 355, /* GL_DRAW_BUFFER0 */
-+ 358, /* GL_DRAW_BUFFER1 */
-+ 379, /* GL_DRAW_BUFFER2 */
-+ 382, /* GL_DRAW_BUFFER3 */
-+ 385, /* GL_DRAW_BUFFER4 */
-+ 388, /* GL_DRAW_BUFFER5 */
-+ 391, /* GL_DRAW_BUFFER6 */
-+ 394, /* GL_DRAW_BUFFER7 */
-+ 397, /* GL_DRAW_BUFFER8 */
-+ 400, /* GL_DRAW_BUFFER9 */
-+ 359, /* GL_DRAW_BUFFER10 */
-+ 362, /* GL_DRAW_BUFFER11 */
-+ 365, /* GL_DRAW_BUFFER12 */
-+ 368, /* GL_DRAW_BUFFER13 */
-+ 371, /* GL_DRAW_BUFFER14 */
-+ 374, /* GL_DRAW_BUFFER15 */
-+ 82, /* GL_BLEND_EQUATION_ALPHA */
-+ 792, /* GL_MATRIX_PALETTE_ARB */
-+ 823, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-+ 826, /* GL_MAX_PALETTE_MATRICES_ARB */
-+ 289, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-+ 786, /* GL_MATRIX_INDEX_ARRAY_ARB */
-+ 284, /* GL_CURRENT_MATRIX_INDEX_ARB */
-+ 788, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-+ 790, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-+ 789, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-+ 787, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-+ 1573, /* GL_TEXTURE_DEPTH_SIZE */
-+ 339, /* GL_DEPTH_TEXTURE_MODE */
-+ 1539, /* GL_TEXTURE_COMPARE_MODE */
-+ 1537, /* GL_TEXTURE_COMPARE_FUNC */
-+ 217, /* GL_COMPARE_R_TO_TEXTURE */
-+ 1093, /* GL_POINT_SPRITE */
-+ 266, /* GL_COORD_REPLACE */
-+ 1097, /* GL_POINT_SPRITE_R_MODE_NV */
-+ 1214, /* GL_QUERY_COUNTER_BITS */
-+ 291, /* GL_CURRENT_QUERY */
-+ 1216, /* GL_QUERY_RESULT */
-+ 1218, /* GL_QUERY_RESULT_AVAILABLE */
-+ 873, /* GL_MAX_VERTEX_ATTRIBS */
-+ 1704, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-+ 337, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-+ 336, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-+ 859, /* GL_MAX_TEXTURE_COORDS */
-+ 861, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-+ 1164, /* GL_PROGRAM_ERROR_STRING_ARB */
-+ 1166, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-+ 1165, /* GL_PROGRAM_FORMAT_ARB */
-+ 1618, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-+ 318, /* GL_DEPTH_BOUNDS_TEST_EXT */
-+ 317, /* GL_DEPTH_BOUNDS_EXT */
-+ 52, /* GL_ARRAY_BUFFER */
-+ 420, /* GL_ELEMENT_ARRAY_BUFFER */
-+ 54, /* GL_ARRAY_BUFFER_BINDING */
-+ 422, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-+ 1678, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-+ 960, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-+ 140, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-+ 579, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-+ 1552, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-+ 416, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-+ 1323, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-+ 463, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-+ 1730, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-+ 1700, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-+ 1167, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-+ 835, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-+ 1173, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+ 844, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+ 1185, /* GL_PROGRAM_TEMPORARIES_ARB */
-+ 850, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-+ 1175, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+ 846, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+ 1179, /* GL_PROGRAM_PARAMETERS_ARB */
-+ 849, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-+ 1174, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-+ 845, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-+ 1160, /* GL_PROGRAM_ATTRIBS_ARB */
-+ 830, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-+ 1172, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-+ 843, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-+ 1158, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-+ 828, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-+ 1170, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+ 841, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+ 836, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-+ 832, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-+ 1188, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-+ 1629, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-+ 1226, /* GL_READ_ONLY */
-+ 1738, /* GL_WRITE_ONLY */
-+ 1228, /* GL_READ_WRITE */
-+ 101, /* GL_BUFFER_ACCESS */
-+ 103, /* GL_BUFFER_MAPPED */
-+ 105, /* GL_BUFFER_MAP_POINTER */
-+ 1623, /* GL_TIME_ELAPSED_EXT */
-+ 746, /* GL_MATRIX0_ARB */
-+ 758, /* GL_MATRIX1_ARB */
-+ 770, /* GL_MATRIX2_ARB */
-+ 774, /* GL_MATRIX3_ARB */
-+ 776, /* GL_MATRIX4_ARB */
-+ 778, /* GL_MATRIX5_ARB */
-+ 780, /* GL_MATRIX6_ARB */
-+ 782, /* GL_MATRIX7_ARB */
-+ 784, /* GL_MATRIX8_ARB */
-+ 785, /* GL_MATRIX9_ARB */
-+ 748, /* GL_MATRIX10_ARB */
-+ 749, /* GL_MATRIX11_ARB */
-+ 750, /* GL_MATRIX12_ARB */
-+ 751, /* GL_MATRIX13_ARB */
-+ 752, /* GL_MATRIX14_ARB */
-+ 753, /* GL_MATRIX15_ARB */
-+ 754, /* GL_MATRIX16_ARB */
-+ 755, /* GL_MATRIX17_ARB */
-+ 756, /* GL_MATRIX18_ARB */
-+ 757, /* GL_MATRIX19_ARB */
-+ 760, /* GL_MATRIX20_ARB */
-+ 761, /* GL_MATRIX21_ARB */
-+ 762, /* GL_MATRIX22_ARB */
-+ 763, /* GL_MATRIX23_ARB */
-+ 764, /* GL_MATRIX24_ARB */
-+ 765, /* GL_MATRIX25_ARB */
-+ 766, /* GL_MATRIX26_ARB */
-+ 767, /* GL_MATRIX27_ARB */
-+ 768, /* GL_MATRIX28_ARB */
-+ 769, /* GL_MATRIX29_ARB */
-+ 772, /* GL_MATRIX30_ARB */
-+ 773, /* GL_MATRIX31_ARB */
-+ 1425, /* GL_STREAM_DRAW */
-+ 1427, /* GL_STREAM_READ */
-+ 1423, /* GL_STREAM_COPY */
-+ 1391, /* GL_STATIC_DRAW */
-+ 1393, /* GL_STATIC_READ */
-+ 1389, /* GL_STATIC_COPY */
-+ 410, /* GL_DYNAMIC_DRAW */
-+ 412, /* GL_DYNAMIC_READ */
-+ 408, /* GL_DYNAMIC_COPY */
-+ 535, /* GL_GL_PIXEL_PACK_BUFFER */
-+ 537, /* GL_GL_PIXEL_UNPACK_BUFFER */
-+ 536, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */
-+ 538, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */
-+ 833, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-+ 831, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-+ 834, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-+ 838, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-+ 837, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-+ 795, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-+ 1419, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-+ 17, /* GL_ACTIVE_STENCIL_FACE_EXT */
-+ 894, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-+ 1304, /* GL_SAMPLES_PASSED */
-+ 486, /* GL_FRAGMENT_SHADER */
-+ 1724, /* GL_VERTEX_SHADER */
-+ 1178, /* GL_PROGRAM_OBJECT_ARB */
-+ 1336, /* GL_SHADER_OBJECT_ARB */
-+ 819, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-+ 877, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-+ 871, /* GL_MAX_VARYING_FLOATS */
-+ 875, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-+ 804, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-+ 985, /* GL_OBJECT_TYPE_ARB */
-+ 1338, /* GL_SHADER_TYPE */
-+ 451, /* GL_FLOAT_VEC2 */
-+ 453, /* GL_FLOAT_VEC3 */
-+ 455, /* GL_FLOAT_VEC4 */
-+ 606, /* GL_INT_VEC2 */
-+ 608, /* GL_INT_VEC3 */
-+ 610, /* GL_INT_VEC4 */
-+ 93, /* GL_BOOL */
-+ 95, /* GL_BOOL_VEC2 */
-+ 97, /* GL_BOOL_VEC3 */
-+ 99, /* GL_BOOL_VEC4 */
-+ 445, /* GL_FLOAT_MAT2 */
-+ 447, /* GL_FLOAT_MAT3 */
-+ 449, /* GL_FLOAT_MAT4 */
-+ 1295, /* GL_SAMPLER_1D */
-+ 1297, /* GL_SAMPLER_2D */
-+ 1299, /* GL_SAMPLER_3D */
-+ 1300, /* GL_SAMPLER_CUBE */
-+ 1296, /* GL_SAMPLER_1D_SHADOW */
-+ 1298, /* GL_SAMPLER_2D_SHADOW */
-+ 529, /* GL_GL_FLOAT_MAT2x3 */
-+ 530, /* GL_GL_FLOAT_MAT2x4 */
-+ 531, /* GL_GL_FLOAT_MAT3x2 */
-+ 532, /* GL_GL_FLOAT_MAT3x4 */
-+ 533, /* GL_GL_FLOAT_MAT4x2 */
-+ 534, /* GL_GL_FLOAT_MAT4x3 */
-+ 312, /* GL_DELETE_STATUS */
-+ 221, /* GL_COMPILE_STATUS */
-+ 659, /* GL_LINK_STATUS */
-+ 1673, /* GL_VALIDATE_STATUS */
-+ 591, /* GL_INFO_LOG_LENGTH */
-+ 56, /* GL_ATTACHED_SHADERS */
-+ 20, /* GL_ACTIVE_UNIFORMS */
-+ 21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-+ 1337, /* GL_SHADER_SOURCE_LENGTH */
-+ 15, /* GL_ACTIVE_ATTRIBUTES */
-+ 16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
-+ 488, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-+ 1340, /* GL_SHADING_LANGUAGE_VERSION */
-+ 290, /* GL_CURRENT_PROGRAM */
-+ 1034, /* GL_PALETTE4_RGB8_OES */
-+ 1036, /* GL_PALETTE4_RGBA8_OES */
-+ 1032, /* GL_PALETTE4_R5_G6_B5_OES */
-+ 1035, /* GL_PALETTE4_RGBA4_OES */
-+ 1033, /* GL_PALETTE4_RGB5_A1_OES */
-+ 1039, /* GL_PALETTE8_RGB8_OES */
-+ 1041, /* GL_PALETTE8_RGBA8_OES */
-+ 1037, /* GL_PALETTE8_R5_G6_B5_OES */
-+ 1040, /* GL_PALETTE8_RGBA4_OES */
-+ 1038, /* GL_PALETTE8_RGB5_A1_OES */
-+ 574, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-+ 573, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-+ 1507, /* GL_TEXTURE_1D_ARRAY_EXT */
-+ 1198, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-+ 1509, /* GL_TEXTURE_2D_ARRAY_EXT */
-+ 1201, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-+ 1515, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-+ 1517, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-+ 543, /* GL_GL_SRGB */
-+ 544, /* GL_GL_SRGB8 */
-+ 546, /* GL_GL_SRGB_ALPHA */
-+ 545, /* GL_GL_SRGB8_ALPHA8 */
-+ 542, /* GL_GL_SLUMINANCE_ALPHA */
-+ 541, /* GL_GL_SLUMINANCE8_ALPHA8 */
-+ 539, /* GL_GL_SLUMINANCE */
-+ 540, /* GL_GL_SLUMINANCE8 */
-+ 526, /* GL_GL_COMPRESSED_SRGB */
-+ 527, /* GL_GL_COMPRESSED_SRGB_ALPHA */
-+ 524, /* GL_GL_COMPRESSED_SLUMINANCE */
-+ 525, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */
-+ 1095, /* GL_POINT_SPRITE_COORD_ORIGIN */
-+ 667, /* GL_LOWER_LEFT */
-+ 1670, /* GL_UPPER_LEFT */
-+ 1401, /* GL_STENCIL_BACK_REF */
-+ 1402, /* GL_STENCIL_BACK_VALUE_MASK */
-+ 1403, /* GL_STENCIL_BACK_WRITEMASK */
-+ 403, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-+ 1240, /* GL_RENDERBUFFER_BINDING_EXT */
-+ 1225, /* GL_READ_FRAMEBUFFER_EXT */
-+ 404, /* GL_DRAW_FRAMEBUFFER_EXT */
-+ 1224, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-+ 490, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-+ 489, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-+ 494, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-+ 492, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-+ 491, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-+ 496, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-+ 498, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-+ 503, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-+ 501, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-+ 499, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-+ 502, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-+ 500, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-+ 504, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-+ 506, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-+ 505, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-+ 801, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-+ 146, /* GL_COLOR_ATTACHMENT0_EXT */
-+ 153, /* GL_COLOR_ATTACHMENT1_EXT */
-+ 154, /* GL_COLOR_ATTACHMENT2_EXT */
-+ 155, /* GL_COLOR_ATTACHMENT3_EXT */
-+ 156, /* GL_COLOR_ATTACHMENT4_EXT */
-+ 157, /* GL_COLOR_ATTACHMENT5_EXT */
-+ 158, /* GL_COLOR_ATTACHMENT6_EXT */
-+ 159, /* GL_COLOR_ATTACHMENT7_EXT */
-+ 160, /* GL_COLOR_ATTACHMENT8_EXT */
-+ 161, /* GL_COLOR_ATTACHMENT9_EXT */
-+ 147, /* GL_COLOR_ATTACHMENT10_EXT */
-+ 148, /* GL_COLOR_ATTACHMENT11_EXT */
-+ 149, /* GL_COLOR_ATTACHMENT12_EXT */
-+ 150, /* GL_COLOR_ATTACHMENT13_EXT */
-+ 151, /* GL_COLOR_ATTACHMENT14_EXT */
-+ 152, /* GL_COLOR_ATTACHMENT15_EXT */
-+ 314, /* GL_DEPTH_ATTACHMENT_EXT */
-+ 1396, /* GL_STENCIL_ATTACHMENT_EXT */
-+ 497, /* GL_FRAMEBUFFER_EXT */
-+ 1241, /* GL_RENDERBUFFER_EXT */
-+ 1244, /* GL_RENDERBUFFER_WIDTH_EXT */
-+ 1242, /* GL_RENDERBUFFER_HEIGHT_EXT */
-+ 1243, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-+ 1414, /* GL_STENCIL_INDEX_EXT */
-+ 1411, /* GL_STENCIL_INDEX1_EXT */
-+ 1412, /* GL_STENCIL_INDEX4_EXT */
-+ 1413, /* GL_STENCIL_INDEX8_EXT */
-+ 1410, /* GL_STENCIL_INDEX16_EXT */
-+ 428, /* GL_EVAL_BIT */
-+ 1222, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-+ 661, /* GL_LIST_BIT */
-+ 1523, /* GL_TEXTURE_BIT */
-+ 1319, /* GL_SCISSOR_BIT */
-+ 29, /* GL_ALL_ATTRIB_BITS */
-+ 941, /* GL_MULTISAMPLE_BIT */
-+ 30, /* GL_ALL_CLIENT_ATTRIB_BITS */
-+};
-+
-+#define Elements(x) sizeof(x)/sizeof(*x)
-+
-+typedef int (*cfunc)(const void *, const void *);
-+
-+/**
-+ * Compare a key name to an element in the \c all_enums array.
-+ *
-+ * \c bsearch always passes the key as the first parameter and the pointer
-+ * to the array element as the second parameter. We can elimiate some
-+ * extra work by taking advantage of that fact.
-+ *
-+ * \param a Pointer to the desired enum name.
-+ * \param b Pointer to an element of the \c all_enums array.
-+ */
-+static int compar_name( const char *a, const enum_elt *b )
-+{
-+ return _mesa_strcmp( a, & enum_string_table[ b->offset ] );
-+}
-+
-+/**
-+ * Compare a key enum value to an element in the \c all_enums array.
-+ *
-+ * \c bsearch always passes the key as the first parameter and the pointer
-+ * to the array element as the second parameter. We can elimiate some
-+ * extra work by taking advantage of that fact.
-+ *
-+ * \param a Pointer to the desired enum name.
-+ * \param b Pointer to an index into the \c all_enums array.
-+ */
-+static int compar_nr( const int *a, const unsigned *b )
-+{
-+ return a[0] - all_enums[*b].n;
-+}
-+
-+
-+static char token_tmp[20];
-+
-+const char *_mesa_lookup_enum_by_nr( int nr )
-+{
-+ unsigned * i;
-+
-+ i = (unsigned *)bsearch( & nr, reduced_enums, Elements(reduced_enums),
-+ sizeof(reduced_enums[0]), (cfunc) compar_nr );
-+
-+ if ( i != NULL ) {
-+ return & enum_string_table[ all_enums[ *i ].offset ];
-+ }
-+ else {
-+ /* this is not re-entrant safe, no big deal here */
-+ _mesa_sprintf(token_tmp, "0x%x", nr);
-+ return token_tmp;
-+ }
-+}
-+
-+int _mesa_lookup_enum_by_name( const char *symbol )
-+{
-+ enum_elt * f = NULL;
-+
-+ if ( symbol != NULL ) {
-+ f = (enum_elt *)bsearch( symbol, all_enums, Elements(all_enums),
-+ sizeof( enum_elt ), (cfunc) compar_name );
-+ }
-+
-+ return (f != NULL) ? f->n : -1;
-+}
-+
-+
-Index: qemu-0.14.0/target-i386/mesa_get.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/mesa_get.c
-@@ -0,0 +1,5563 @@
-+
-+/***
-+ *** NOTE!!! DO NOT EDIT THIS FILE!!! IT IS GENERATED BY get_gen.py
-+ ***/
-+
-+#include "glheader.h"
-+#include "context.h"
-+#include "enable.h"
-+#include "extensions.h"
-+#include "fbobject.h"
-+#include "get.h"
-+#include "macros.h"
-+#include "mtypes.h"
-+#include "state.h"
-+#include "texcompress.h"
-+
-+
-+#define FLOAT_TO_BOOLEAN(X) ( (X) ? GL_TRUE : GL_FALSE )
-+
-+#define INT_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE )
-+
-+#define ENUM_TO_BOOLEAN(E) ( (E) ? GL_TRUE : GL_FALSE )
-+#define ENUM_TO_INT(E) ( (GLint) (E) )
-+#define ENUM_TO_FLOAT(E) ( (GLfloat) (E) )
-+
-+#define BOOLEAN_TO_INT(B) ( (GLint) (B) )
-+#define BOOLEAN_TO_FLOAT(B) ( (B) ? 1.0F : 0.0F )
-+
-+
-+/*
-+ * Check if named extension is enabled, if not generate error and return.
-+ */
-+#define CHECK_EXT1(EXT1, FUNC) \
-+ if (!ctx->Extensions.EXT1) { \
-+ _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname); \
-+ return; \
-+ }
-+
-+/*
-+ * Check if either of two extensions is enabled.
-+ */
-+#define CHECK_EXT2(EXT1, EXT2, FUNC) \
-+ if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \
-+ _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname); \
-+ return; \
-+ }
-+
-+/*
-+ * Check if either of three extensions is enabled.
-+ */
-+#define CHECK_EXT3(EXT1, EXT2, EXT3, FUNC) \
-+ if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2 && \
-+ !ctx->Extensions.EXT3) { \
-+ _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname); \
-+ return; \
-+ }
-+
-+/*
-+ * Check if either of four extensions is enabled.
-+ */
-+#define CHECK_EXT4(EXT1, EXT2, EXT3, EXT4, FUNC) \
-+ if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2 && \
-+ !ctx->Extensions.EXT3 && !ctx->Extensions.EXT4) { \
-+ _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname); \
-+ return; \
-+ }
-+
-+
-+void GLAPIENTRY
-+_mesa_GetBooleanv( GLenum pname, GLboolean *params )
-+{
-+ GET_CURRENT_CONTEXT(ctx);
-+ ASSERT_OUTSIDE_BEGIN_END(ctx);
-+
-+ if (!params)
-+ return;
-+
-+ if (ctx->NewState)
-+ _mesa_update_state(ctx);
-+
-+ if (ctx->Driver.GetBooleanv &&
-+ ctx->Driver.GetBooleanv(ctx, pname, params))
-+ return;
-+
-+ switch (pname) {
-+ case GL_ACCUM_RED_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumRedBits);
-+ break;
-+ case GL_ACCUM_GREEN_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumGreenBits);
-+ break;
-+ case GL_ACCUM_BLUE_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumBlueBits);
-+ break;
-+ case GL_ACCUM_ALPHA_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumAlphaBits);
-+ break;
-+ case GL_ACCUM_CLEAR_VALUE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[3]);
-+ break;
-+ case GL_ALPHA_BIAS:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.AlphaBias);
-+ break;
-+ case GL_ALPHA_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.alphaBits);
-+ break;
-+ case GL_ALPHA_SCALE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.AlphaScale);
-+ break;
-+ case GL_ALPHA_TEST:
-+ params[0] = ctx->Color.AlphaEnabled;
-+ break;
-+ case GL_ALPHA_TEST_FUNC:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.AlphaFunc);
-+ break;
-+ case GL_ALPHA_TEST_REF:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Color.AlphaRef);
-+ break;
-+ case GL_ATTRIB_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->AttribStackDepth);
-+ break;
-+ case GL_AUTO_NORMAL:
-+ params[0] = ctx->Eval.AutoNormal;
-+ break;
-+ case GL_AUX_BUFFERS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.numAuxBuffers);
-+ break;
-+ case GL_BLEND:
-+ params[0] = ctx->Color.BlendEnabled;
-+ break;
-+ case GL_BLEND_DST:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstRGB);
-+ break;
-+ case GL_BLEND_SRC:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcRGB);
-+ break;
-+ case GL_BLEND_SRC_RGB_EXT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcRGB);
-+ break;
-+ case GL_BLEND_DST_RGB_EXT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstRGB);
-+ break;
-+ case GL_BLEND_SRC_ALPHA_EXT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcA);
-+ break;
-+ case GL_BLEND_DST_ALPHA_EXT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstA);
-+ break;
-+ case GL_BLEND_EQUATION:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendEquationRGB );
-+ break;
-+ case GL_BLEND_EQUATION_ALPHA_EXT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendEquationA );
-+ break;
-+ case GL_BLEND_COLOR_EXT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[3]);
-+ break;
-+ case GL_BLUE_BIAS:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.BlueBias);
-+ break;
-+ case GL_BLUE_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.blueBits);
-+ break;
-+ case GL_BLUE_SCALE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.BlueScale);
-+ break;
-+ case GL_CLIENT_ATTRIB_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->ClientAttribStackDepth);
-+ break;
-+ case GL_CLIP_PLANE0:
-+ params[0] = (ctx->Transform.ClipPlanesEnabled >> 0) & 1;
-+ break;
-+ case GL_CLIP_PLANE1:
-+ params[0] = (ctx->Transform.ClipPlanesEnabled >> 1) & 1;
-+ break;
-+ case GL_CLIP_PLANE2:
-+ params[0] = (ctx->Transform.ClipPlanesEnabled >> 2) & 1;
-+ break;
-+ case GL_CLIP_PLANE3:
-+ params[0] = (ctx->Transform.ClipPlanesEnabled >> 3) & 1;
-+ break;
-+ case GL_CLIP_PLANE4:
-+ params[0] = (ctx->Transform.ClipPlanesEnabled >> 4) & 1;
-+ break;
-+ case GL_CLIP_PLANE5:
-+ params[0] = (ctx->Transform.ClipPlanesEnabled >> 5) & 1;
-+ break;
-+ case GL_COLOR_CLEAR_VALUE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[3]);
-+ break;
-+ case GL_COLOR_MATERIAL:
-+ params[0] = ctx->Light.ColorMaterialEnabled;
-+ break;
-+ case GL_COLOR_MATERIAL_FACE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Light.ColorMaterialFace);
-+ break;
-+ case GL_COLOR_MATERIAL_PARAMETER:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Light.ColorMaterialMode);
-+ break;
-+ case GL_COLOR_WRITEMASK:
-+ params[0] = INT_TO_BOOLEAN(ctx->Color.ColorMask[RCOMP] ? 1 : 0);
-+ params[1] = INT_TO_BOOLEAN(ctx->Color.ColorMask[GCOMP] ? 1 : 0);
-+ params[2] = INT_TO_BOOLEAN(ctx->Color.ColorMask[BCOMP] ? 1 : 0);
-+ params[3] = INT_TO_BOOLEAN(ctx->Color.ColorMask[ACOMP] ? 1 : 0);
-+ break;
-+ case GL_CULL_FACE:
-+ params[0] = ctx->Polygon.CullFlag;
-+ break;
-+ case GL_CULL_FACE_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.CullFaceMode);
-+ break;
-+ case GL_CURRENT_COLOR:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
-+ }
-+ break;
-+ case GL_CURRENT_INDEX:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]);
-+ }
-+ break;
-+ case GL_CURRENT_NORMAL:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
-+ }
-+ break;
-+ case GL_CURRENT_RASTER_COLOR:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[3]);
-+ break;
-+ case GL_CURRENT_RASTER_DISTANCE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterDistance);
-+ break;
-+ case GL_CURRENT_RASTER_INDEX:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterIndex);
-+ break;
-+ case GL_CURRENT_RASTER_POSITION:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[3]);
-+ break;
-+ case GL_CURRENT_RASTER_SECONDARY_COLOR:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[3]);
-+ break;
-+ case GL_CURRENT_RASTER_TEXTURE_COORDS:
-+ {
-+ const GLuint texUnit = ctx->Texture.CurrentUnit;
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][3]);
-+ }
-+ break;
-+ case GL_CURRENT_RASTER_POSITION_VALID:
-+ params[0] = ctx->Current.RasterPosValid;
-+ break;
-+ case GL_CURRENT_TEXTURE_COORDS:
-+ {
-+ const GLuint texUnit = ctx->Texture.CurrentUnit;
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
-+ }
-+ break;
-+ case GL_DEPTH_BIAS:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.DepthBias);
-+ break;
-+ case GL_DEPTH_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.depthBits);
-+ break;
-+ case GL_DEPTH_CLEAR_VALUE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.Clear);
-+ break;
-+ case GL_DEPTH_FUNC:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Depth.Func);
-+ break;
-+ case GL_DEPTH_RANGE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Viewport.Near);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Viewport.Far);
-+ break;
-+ case GL_DEPTH_SCALE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.DepthScale);
-+ break;
-+ case GL_DEPTH_TEST:
-+ params[0] = ctx->Depth.Test;
-+ break;
-+ case GL_DEPTH_WRITEMASK:
-+ params[0] = ctx->Depth.Mask;
-+ break;
-+ case GL_DITHER:
-+ params[0] = ctx->Color.DitherFlag;
-+ break;
-+ case GL_DOUBLEBUFFER:
-+ params[0] = ctx->DrawBuffer->Visual.doubleBufferMode;
-+ break;
-+ case GL_DRAW_BUFFER:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+ break;
-+ case GL_EDGE_FLAG:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = ctx->Current.EdgeFlag;
-+ }
-+ break;
-+ case GL_FEEDBACK_BUFFER_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Feedback.BufferSize);
-+ break;
-+ case GL_FEEDBACK_BUFFER_TYPE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Feedback.Type);
-+ break;
-+ case GL_FOG:
-+ params[0] = ctx->Fog.Enabled;
-+ break;
-+ case GL_FOG_COLOR:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[3]);
-+ break;
-+ case GL_FOG_DENSITY:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Density);
-+ break;
-+ case GL_FOG_END:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.End);
-+ break;
-+ case GL_FOG_HINT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.Fog);
-+ break;
-+ case GL_FOG_INDEX:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Index);
-+ break;
-+ case GL_FOG_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Fog.Mode);
-+ break;
-+ case GL_FOG_START:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Start);
-+ break;
-+ case GL_FRONT_FACE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.FrontFace);
-+ break;
-+ case GL_GREEN_BIAS:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.GreenBias);
-+ break;
-+ case GL_GREEN_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.greenBits);
-+ break;
-+ case GL_GREEN_SCALE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.GreenScale);
-+ break;
-+ case GL_INDEX_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.indexBits);
-+ break;
-+ case GL_INDEX_CLEAR_VALUE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Color.ClearIndex);
-+ break;
-+ case GL_INDEX_MODE:
-+ params[0] = !ctx->DrawBuffer->Visual.rgbMode;
-+ break;
-+ case GL_INDEX_OFFSET:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.IndexOffset);
-+ break;
-+ case GL_INDEX_SHIFT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.IndexShift);
-+ break;
-+ case GL_INDEX_WRITEMASK:
-+ params[0] = INT_TO_BOOLEAN(ctx->Color.IndexMask);
-+ break;
-+ case GL_LIGHT0:
-+ params[0] = ctx->Light.Light[0].Enabled;
-+ break;
-+ case GL_LIGHT1:
-+ params[0] = ctx->Light.Light[1].Enabled;
-+ break;
-+ case GL_LIGHT2:
-+ params[0] = ctx->Light.Light[2].Enabled;
-+ break;
-+ case GL_LIGHT3:
-+ params[0] = ctx->Light.Light[3].Enabled;
-+ break;
-+ case GL_LIGHT4:
-+ params[0] = ctx->Light.Light[4].Enabled;
-+ break;
-+ case GL_LIGHT5:
-+ params[0] = ctx->Light.Light[5].Enabled;
-+ break;
-+ case GL_LIGHT6:
-+ params[0] = ctx->Light.Light[6].Enabled;
-+ break;
-+ case GL_LIGHT7:
-+ params[0] = ctx->Light.Light[7].Enabled;
-+ break;
-+ case GL_LIGHTING:
-+ params[0] = ctx->Light.Enabled;
-+ break;
-+ case GL_LIGHT_MODEL_AMBIENT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[3]);
-+ break;
-+ case GL_LIGHT_MODEL_COLOR_CONTROL:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Light.Model.ColorControl);
-+ break;
-+ case GL_LIGHT_MODEL_LOCAL_VIEWER:
-+ params[0] = ctx->Light.Model.LocalViewer;
-+ break;
-+ case GL_LIGHT_MODEL_TWO_SIDE:
-+ params[0] = ctx->Light.Model.TwoSide;
-+ break;
-+ case GL_LINE_SMOOTH:
-+ params[0] = ctx->Line.SmoothFlag;
-+ break;
-+ case GL_LINE_SMOOTH_HINT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.LineSmooth);
-+ break;
-+ case GL_LINE_STIPPLE:
-+ params[0] = ctx->Line.StippleFlag;
-+ break;
-+ case GL_LINE_STIPPLE_PATTERN:
-+ params[0] = INT_TO_BOOLEAN(ctx->Line.StipplePattern);
-+ break;
-+ case GL_LINE_STIPPLE_REPEAT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Line.StippleFactor);
-+ break;
-+ case GL_LINE_WIDTH:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Line.Width);
-+ break;
-+ case GL_LINE_WIDTH_GRANULARITY:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.LineWidthGranularity);
-+ break;
-+ case GL_LINE_WIDTH_RANGE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinLineWidthAA);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxLineWidthAA);
-+ break;
-+ case GL_ALIASED_LINE_WIDTH_RANGE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinLineWidth);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxLineWidth);
-+ break;
-+ case GL_LIST_BASE:
-+ params[0] = INT_TO_BOOLEAN(ctx->List.ListBase);
-+ break;
-+ case GL_LIST_INDEX:
-+ params[0] = INT_TO_BOOLEAN(ctx->ListState.CurrentListNum);
-+ break;
-+ case GL_LIST_MODE:
-+ {
-+ GLenum mode;
-+ if (!ctx->CompileFlag)
-+ mode = 0;
-+ else if (ctx->ExecuteFlag)
-+ mode = GL_COMPILE_AND_EXECUTE;
-+ else
-+ mode = GL_COMPILE;
-+ params[0] = ENUM_TO_BOOLEAN(mode);
-+ }
-+ break;
-+ case GL_INDEX_LOGIC_OP:
-+ params[0] = ctx->Color.IndexLogicOpEnabled;
-+ break;
-+ case GL_COLOR_LOGIC_OP:
-+ params[0] = ctx->Color.ColorLogicOpEnabled;
-+ break;
-+ case GL_LOGIC_OP_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Color.LogicOp);
-+ break;
-+ case GL_MAP1_COLOR_4:
-+ params[0] = ctx->Eval.Map1Color4;
-+ break;
-+ case GL_MAP1_GRID_DOMAIN:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid1u1);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid1u2);
-+ break;
-+ case GL_MAP1_GRID_SEGMENTS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Eval.MapGrid1un);
-+ break;
-+ case GL_MAP1_INDEX:
-+ params[0] = ctx->Eval.Map1Index;
-+ break;
-+ case GL_MAP1_NORMAL:
-+ params[0] = ctx->Eval.Map1Normal;
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_1:
-+ params[0] = ctx->Eval.Map1TextureCoord1;
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_2:
-+ params[0] = ctx->Eval.Map1TextureCoord2;
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_3:
-+ params[0] = ctx->Eval.Map1TextureCoord3;
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_4:
-+ params[0] = ctx->Eval.Map1TextureCoord4;
-+ break;
-+ case GL_MAP1_VERTEX_3:
-+ params[0] = ctx->Eval.Map1Vertex3;
-+ break;
-+ case GL_MAP1_VERTEX_4:
-+ params[0] = ctx->Eval.Map1Vertex4;
-+ break;
-+ case GL_MAP2_COLOR_4:
-+ params[0] = ctx->Eval.Map2Color4;
-+ break;
-+ case GL_MAP2_GRID_DOMAIN:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2u1);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2u2);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2v1);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2v2);
-+ break;
-+ case GL_MAP2_GRID_SEGMENTS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Eval.MapGrid2un);
-+ params[1] = INT_TO_BOOLEAN(ctx->Eval.MapGrid2vn);
-+ break;
-+ case GL_MAP2_INDEX:
-+ params[0] = ctx->Eval.Map2Index;
-+ break;
-+ case GL_MAP2_NORMAL:
-+ params[0] = ctx->Eval.Map2Normal;
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_1:
-+ params[0] = ctx->Eval.Map2TextureCoord1;
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_2:
-+ params[0] = ctx->Eval.Map2TextureCoord2;
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_3:
-+ params[0] = ctx->Eval.Map2TextureCoord3;
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_4:
-+ params[0] = ctx->Eval.Map2TextureCoord4;
-+ break;
-+ case GL_MAP2_VERTEX_3:
-+ params[0] = ctx->Eval.Map2Vertex3;
-+ break;
-+ case GL_MAP2_VERTEX_4:
-+ params[0] = ctx->Eval.Map2Vertex4;
-+ break;
-+ case GL_MAP_COLOR:
-+ params[0] = ctx->Pixel.MapColorFlag;
-+ break;
-+ case GL_MAP_STENCIL:
-+ params[0] = ctx->Pixel.MapStencilFlag;
-+ break;
-+ case GL_MATRIX_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Transform.MatrixMode);
-+ break;
-+ case GL_MAX_ATTRIB_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(MAX_ATTRIB_STACK_DEPTH);
-+ break;
-+ case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(MAX_CLIENT_ATTRIB_STACK_DEPTH);
-+ break;
-+ case GL_MAX_CLIP_PLANES:
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxClipPlanes);
-+ break;
-+ case GL_MAX_ELEMENTS_VERTICES:
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxArrayLockSize);
-+ break;
-+ case GL_MAX_ELEMENTS_INDICES:
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxArrayLockSize);
-+ break;
-+ case GL_MAX_EVAL_ORDER:
-+ params[0] = INT_TO_BOOLEAN(MAX_EVAL_ORDER);
-+ break;
-+ case GL_MAX_LIGHTS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxLights);
-+ break;
-+ case GL_MAX_LIST_NESTING:
-+ params[0] = INT_TO_BOOLEAN(MAX_LIST_NESTING);
-+ break;
-+ case GL_MAX_MODELVIEW_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(MAX_MODELVIEW_STACK_DEPTH);
-+ break;
-+ case GL_MAX_NAME_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(MAX_NAME_STACK_DEPTH);
-+ break;
-+ case GL_MAX_PIXEL_MAP_TABLE:
-+ params[0] = INT_TO_BOOLEAN(MAX_PIXEL_MAP_TABLE);
-+ break;
-+ case GL_MAX_PROJECTION_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(MAX_PROJECTION_STACK_DEPTH);
-+ break;
-+ case GL_MAX_TEXTURE_SIZE:
-+ params[0] = INT_TO_BOOLEAN(1 << (ctx->Const.MaxTextureLevels - 1));
-+ break;
-+ case GL_MAX_3D_TEXTURE_SIZE:
-+ params[0] = INT_TO_BOOLEAN(1 << (ctx->Const.Max3DTextureLevels - 1));
-+ break;
-+ case GL_MAX_TEXTURE_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(MAX_TEXTURE_STACK_DEPTH);
-+ break;
-+ case GL_MAX_VIEWPORT_DIMS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxViewportWidth);
-+ params[1] = INT_TO_BOOLEAN(ctx->Const.MaxViewportHeight);
-+ break;
-+ case GL_MODELVIEW_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_MODELVIEW_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->ModelviewMatrixStack.Depth + 1);
-+ break;
-+ case GL_NAME_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->Select.NameStackDepth);
-+ break;
-+ case GL_NORMALIZE:
-+ params[0] = ctx->Transform.Normalize;
-+ break;
-+ case GL_PACK_ALIGNMENT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.Alignment);
-+ break;
-+ case GL_PACK_LSB_FIRST:
-+ params[0] = ctx->Pack.LsbFirst;
-+ break;
-+ case GL_PACK_ROW_LENGTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.RowLength);
-+ break;
-+ case GL_PACK_SKIP_PIXELS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipPixels);
-+ break;
-+ case GL_PACK_SKIP_ROWS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipRows);
-+ break;
-+ case GL_PACK_SWAP_BYTES:
-+ params[0] = ctx->Pack.SwapBytes;
-+ break;
-+ case GL_PACK_SKIP_IMAGES_EXT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipImages);
-+ break;
-+ case GL_PACK_IMAGE_HEIGHT_EXT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.ImageHeight);
-+ break;
-+ case GL_PACK_INVERT_MESA:
-+ params[0] = ctx->Pack.Invert;
-+ break;
-+ case GL_PERSPECTIVE_CORRECTION_HINT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PerspectiveCorrection);
-+ break;
-+ case GL_PIXEL_MAP_A_TO_A_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapAtoAsize);
-+ break;
-+ case GL_PIXEL_MAP_B_TO_B_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapBtoBsize);
-+ break;
-+ case GL_PIXEL_MAP_G_TO_G_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapGtoGsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_A_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoAsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_B_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoBsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_G_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoGsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_I_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoIsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_R_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoRsize);
-+ break;
-+ case GL_PIXEL_MAP_R_TO_R_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapRtoRsize);
-+ break;
-+ case GL_PIXEL_MAP_S_TO_S_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapStoSsize);
-+ break;
-+ case GL_POINT_SIZE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Size);
-+ break;
-+ case GL_POINT_SIZE_GRANULARITY:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.PointSizeGranularity);
-+ break;
-+ case GL_POINT_SIZE_RANGE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinPointSizeAA);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxPointSizeAA);
-+ break;
-+ case GL_ALIASED_POINT_SIZE_RANGE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinPointSize);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxPointSize);
-+ break;
-+ case GL_POINT_SMOOTH:
-+ params[0] = ctx->Point.SmoothFlag;
-+ break;
-+ case GL_POINT_SMOOTH_HINT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PointSmooth);
-+ break;
-+ case GL_POINT_SIZE_MIN_EXT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Point.MinSize);
-+ break;
-+ case GL_POINT_SIZE_MAX_EXT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Point.MaxSize);
-+ break;
-+ case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Threshold);
-+ break;
-+ case GL_DISTANCE_ATTENUATION_EXT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Params[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Point.Params[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Point.Params[2]);
-+ break;
-+ case GL_POLYGON_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.FrontMode);
-+ params[1] = ENUM_TO_BOOLEAN(ctx->Polygon.BackMode);
-+ break;
-+ case GL_POLYGON_OFFSET_BIAS_EXT:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetUnits);
-+ break;
-+ case GL_POLYGON_OFFSET_FACTOR:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetFactor );
-+ break;
-+ case GL_POLYGON_OFFSET_UNITS:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetUnits );
-+ break;
-+ case GL_POLYGON_SMOOTH:
-+ params[0] = ctx->Polygon.SmoothFlag;
-+ break;
-+ case GL_POLYGON_SMOOTH_HINT:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PolygonSmooth);
-+ break;
-+ case GL_POLYGON_STIPPLE:
-+ params[0] = ctx->Polygon.StippleFlag;
-+ break;
-+ case GL_PROJECTION_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_PROJECTION_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->ProjectionMatrixStack.Depth + 1);
-+ break;
-+ case GL_READ_BUFFER:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->ReadBuffer->ColorReadBuffer);
-+ break;
-+ case GL_RED_BIAS:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.RedBias);
-+ break;
-+ case GL_RED_BITS:
-+ params[0] = INT_TO_BOOLEAN( ctx->DrawBuffer->Visual.redBits );
-+ break;
-+ case GL_RED_SCALE:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.RedScale);
-+ break;
-+ case GL_RENDER_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->RenderMode);
-+ break;
-+ case GL_RESCALE_NORMAL:
-+ params[0] = ctx->Transform.RescaleNormals;
-+ break;
-+ case GL_RGBA_MODE:
-+ params[0] = ctx->DrawBuffer->Visual.rgbMode;
-+ break;
-+ case GL_SCISSOR_BOX:
-+ params[0] = INT_TO_BOOLEAN(ctx->Scissor.X);
-+ params[1] = INT_TO_BOOLEAN(ctx->Scissor.Y);
-+ params[2] = INT_TO_BOOLEAN(ctx->Scissor.Width);
-+ params[3] = INT_TO_BOOLEAN(ctx->Scissor.Height);
-+ break;
-+ case GL_SCISSOR_TEST:
-+ params[0] = ctx->Scissor.Enabled;
-+ break;
-+ case GL_SELECTION_BUFFER_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Select.BufferSize);
-+ break;
-+ case GL_SHADE_MODEL:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Light.ShadeModel);
-+ break;
-+ case GL_SHARED_TEXTURE_PALETTE_EXT:
-+ params[0] = ctx->Texture.SharedPalette;
-+ break;
-+ case GL_STENCIL_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.stencilBits);
-+ break;
-+ case GL_STENCIL_CLEAR_VALUE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Stencil.Clear);
-+ break;
-+ case GL_STENCIL_FAIL:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_FUNC:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_PASS_DEPTH_FAIL:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_PASS_DEPTH_PASS:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_REF:
-+ params[0] = INT_TO_BOOLEAN(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_TEST:
-+ params[0] = ctx->Stencil.Enabled;
-+ break;
-+ case GL_STENCIL_VALUE_MASK:
-+ params[0] = INT_TO_BOOLEAN(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_WRITEMASK:
-+ params[0] = INT_TO_BOOLEAN(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STEREO:
-+ params[0] = ctx->DrawBuffer->Visual.stereoMode;
-+ break;
-+ case GL_SUBPIXEL_BITS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.SubPixelBits);
-+ break;
-+ case GL_TEXTURE_1D:
-+ params[0] = _mesa_IsEnabled(GL_TEXTURE_1D);
-+ break;
-+ case GL_TEXTURE_2D:
-+ params[0] = _mesa_IsEnabled(GL_TEXTURE_2D);
-+ break;
-+ case GL_TEXTURE_3D:
-+ params[0] = _mesa_IsEnabled(GL_TEXTURE_3D);
-+ break;
-+ case GL_TEXTURE_BINDING_1D:
-+ params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
-+ break;
-+ case GL_TEXTURE_BINDING_2D:
-+ params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
-+ break;
-+ case GL_TEXTURE_BINDING_3D:
-+ params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
-+ break;
-+ case GL_TEXTURE_ENV_COLOR:
-+ {
-+ const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
-+ params[0] = FLOAT_TO_BOOLEAN(color[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(color[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(color[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(color[3]);
-+ }
-+ break;
-+ case GL_TEXTURE_ENV_MODE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
-+ break;
-+ case GL_TEXTURE_GEN_S:
-+ params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0);
-+ break;
-+ case GL_TEXTURE_GEN_T:
-+ params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0);
-+ break;
-+ case GL_TEXTURE_GEN_R:
-+ params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0);
-+ break;
-+ case GL_TEXTURE_GEN_Q:
-+ params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0);
-+ break;
-+ case GL_TEXTURE_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_TEXTURE_STACK_DEPTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1);
-+ break;
-+ case GL_UNPACK_ALIGNMENT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.Alignment);
-+ break;
-+ case GL_UNPACK_LSB_FIRST:
-+ params[0] = ctx->Unpack.LsbFirst;
-+ break;
-+ case GL_UNPACK_ROW_LENGTH:
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.RowLength);
-+ break;
-+ case GL_UNPACK_SKIP_PIXELS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipPixels);
-+ break;
-+ case GL_UNPACK_SKIP_ROWS:
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipRows);
-+ break;
-+ case GL_UNPACK_SWAP_BYTES:
-+ params[0] = ctx->Unpack.SwapBytes;
-+ break;
-+ case GL_UNPACK_SKIP_IMAGES_EXT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipImages);
-+ break;
-+ case GL_UNPACK_IMAGE_HEIGHT_EXT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.ImageHeight);
-+ break;
-+ case GL_UNPACK_CLIENT_STORAGE_APPLE:
-+ params[0] = ctx->Unpack.ClientStorage;
-+ break;
-+ case GL_VIEWPORT:
-+ params[0] = INT_TO_BOOLEAN(ctx->Viewport.X);
-+ params[1] = INT_TO_BOOLEAN(ctx->Viewport.Y);
-+ params[2] = INT_TO_BOOLEAN(ctx->Viewport.Width);
-+ params[3] = INT_TO_BOOLEAN(ctx->Viewport.Height);
-+ break;
-+ case GL_ZOOM_X:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.ZoomX);
-+ break;
-+ case GL_ZOOM_Y:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.ZoomY);
-+ break;
-+ case GL_VERTEX_ARRAY:
-+ params[0] = ctx->Array.ArrayObj->Vertex.Enabled;
-+ break;
-+ case GL_VERTEX_ARRAY_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.Size);
-+ break;
-+ case GL_VERTEX_ARRAY_TYPE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.Type);
-+ break;
-+ case GL_VERTEX_ARRAY_STRIDE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.Stride);
-+ break;
-+ case GL_VERTEX_ARRAY_COUNT_EXT:
-+ params[0] = INT_TO_BOOLEAN(0);
-+ break;
-+ case GL_NORMAL_ARRAY:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.Enabled);
-+ break;
-+ case GL_NORMAL_ARRAY_TYPE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.Type);
-+ break;
-+ case GL_NORMAL_ARRAY_STRIDE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.Stride);
-+ break;
-+ case GL_NORMAL_ARRAY_COUNT_EXT:
-+ params[0] = INT_TO_BOOLEAN(0);
-+ break;
-+ case GL_COLOR_ARRAY:
-+ params[0] = ctx->Array.ArrayObj->Color.Enabled;
-+ break;
-+ case GL_COLOR_ARRAY_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.Size);
-+ break;
-+ case GL_COLOR_ARRAY_TYPE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Color.Type);
-+ break;
-+ case GL_COLOR_ARRAY_STRIDE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.Stride);
-+ break;
-+ case GL_COLOR_ARRAY_COUNT_EXT:
-+ params[0] = INT_TO_BOOLEAN(0);
-+ break;
-+ case GL_INDEX_ARRAY:
-+ params[0] = ctx->Array.ArrayObj->Index.Enabled;
-+ break;
-+ case GL_INDEX_ARRAY_TYPE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Index.Type);
-+ break;
-+ case GL_INDEX_ARRAY_STRIDE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Index.Stride);
-+ break;
-+ case GL_INDEX_ARRAY_COUNT_EXT:
-+ params[0] = INT_TO_BOOLEAN(0);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY:
-+ params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_SIZE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_TYPE:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
-+ params[0] = INT_TO_BOOLEAN(0);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY:
-+ params[0] = ctx->Array.ArrayObj->EdgeFlag.Enabled;
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_STRIDE:
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->EdgeFlag.Stride);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
-+ params[0] = INT_TO_BOOLEAN(0);
-+ break;
-+ case GL_MAX_TEXTURE_UNITS_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureUnits);
-+ break;
-+ case GL_ACTIVE_TEXTURE_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
-+ break;
-+ case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
-+ break;
-+ case GL_TEXTURE_CUBE_MAP_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-+ params[0] = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-+ break;
-+ case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
-+ break;
-+ case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
-+ break;
-+ case GL_TEXTURE_COMPRESSION_HINT_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Hint.TextureCompression);
-+ break;
-+ case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(_mesa_get_compressed_formats(ctx, NULL, GL_FALSE));
-+ break;
-+ case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
-+ {
-+ GLint formats[100];
-+ GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
-+ ASSERT(n <= 100);
-+ for (i = 0; i < n; i++)
-+ params[i] = ENUM_TO_INT(formats[i]);
-+ }
-+ break;
-+ case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-+ CHECK_EXT1(EXT_compiled_vertex_array, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.LockFirst);
-+ break;
-+ case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-+ CHECK_EXT1(EXT_compiled_vertex_array, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.LockCount);
-+ break;
-+ case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_COLOR_MATRIX_SGI:
-+ {
-+ const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-+ params[0] = INT_TO_BOOLEAN(ctx->ColorMatrixStack.Depth + 1);
-+ break;
-+ case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
-+ params[0] = INT_TO_BOOLEAN(MAX_COLOR_STACK_DEPTH);
-+ break;
-+ case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[0]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[1]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[2]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[3]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[0]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[1]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[2]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[3]);
-+ break;
-+ case GL_CONVOLUTION_1D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = ctx->Pixel.Convolution1DEnabled;
-+ break;
-+ case GL_CONVOLUTION_2D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = ctx->Pixel.Convolution2DEnabled;
-+ break;
-+ case GL_SEPARABLE_2D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = ctx->Pixel.Separable2DEnabled;
-+ break;
-+ case GL_POST_CONVOLUTION_RED_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[0]);
-+ break;
-+ case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[1]);
-+ break;
-+ case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[2]);
-+ break;
-+ case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[3]);
-+ break;
-+ case GL_POST_CONVOLUTION_RED_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[0]);
-+ break;
-+ case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[1]);
-+ break;
-+ case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[2]);
-+ break;
-+ case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[3]);
-+ break;
-+ case GL_HISTOGRAM:
-+ CHECK_EXT1(EXT_histogram, "GetBooleanv");
-+ params[0] = ctx->Pixel.HistogramEnabled;
-+ break;
-+ case GL_MINMAX:
-+ CHECK_EXT1(EXT_histogram, "GetBooleanv");
-+ params[0] = ctx->Pixel.MinMaxEnabled;
-+ break;
-+ case GL_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetBooleanv");
-+ params[0] = ctx->Pixel.ColorTableEnabled;
-+ break;
-+ case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetBooleanv");
-+ params[0] = ctx->Pixel.PostConvolutionColorTableEnabled;
-+ break;
-+ case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetBooleanv");
-+ params[0] = ctx->Pixel.PostColorMatrixColorTableEnabled;
-+ break;
-+ case GL_TEXTURE_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_texture_color_table, "GetBooleanv");
-+ params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
-+ break;
-+ case GL_COLOR_SUM_EXT:
-+ CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Fog.ColorSumEnabled;
-+ break;
-+ case GL_CURRENT_SECONDARY_COLOR_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
-+ params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
-+ params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
-+ }
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->SecondaryColor.Enabled;
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.Type);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.Stride);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.Size);
-+ break;
-+ case GL_CURRENT_FOG_COORDINATE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
-+ }
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->FogCoord.Enabled;
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.Type);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.Stride);
-+ break;
-+ case GL_FOG_COORDINATE_SOURCE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Fog.FogCoordinateSource);
-+ break;
-+ case GL_MAX_TEXTURE_LOD_BIAS_EXT:
-+ CHECK_EXT1(EXT_texture_lod_bias, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureLodBias);
-+ break;
-+ case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-+ CHECK_EXT1(EXT_texture_filter_anisotropic, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureMaxAnisotropy);
-+ break;
-+ case GL_MULTISAMPLE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = ctx->Multisample.Enabled;
-+ break;
-+ case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = ctx->Multisample.SampleAlphaToCoverage;
-+ break;
-+ case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = ctx->Multisample.SampleAlphaToOne;
-+ break;
-+ case GL_SAMPLE_COVERAGE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = ctx->Multisample.SampleCoverage;
-+ break;
-+ case GL_SAMPLE_COVERAGE_VALUE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Multisample.SampleCoverageValue);
-+ break;
-+ case GL_SAMPLE_COVERAGE_INVERT_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = ctx->Multisample.SampleCoverageInvert;
-+ break;
-+ case GL_SAMPLE_BUFFERS_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.sampleBuffers);
-+ break;
-+ case GL_SAMPLES_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.samples);
-+ break;
-+ case GL_RASTER_POSITION_UNCLIPPED_IBM:
-+ CHECK_EXT1(IBM_rasterpos_clip, "GetBooleanv");
-+ params[0] = ctx->Transform.RasterPositionUnclipped;
-+ break;
-+ case GL_POINT_SPRITE_NV:
-+ CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetBooleanv");
-+ params[0] = ctx->Point.PointSprite;
-+ break;
-+ case GL_POINT_SPRITE_R_MODE_NV:
-+ CHECK_EXT1(NV_point_sprite, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Point.SpriteRMode);
-+ break;
-+ case GL_POINT_SPRITE_COORD_ORIGIN:
-+ CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Point.SpriteOrigin);
-+ break;
-+ case GL_GENERATE_MIPMAP_HINT_SGIS:
-+ CHECK_EXT1(SGIS_generate_mipmap, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.GenerateMipmap);
-+ break;
-+ case GL_VERTEX_PROGRAM_BINDING_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN((ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0));
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY0_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[0].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY1_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[1].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY2_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[2].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY3_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[3].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[4].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY5_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[5].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY6_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[6].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY7_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[7].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY8_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[8].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY9_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[9].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY10_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[10].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY11_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[11].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY12_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[12].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY13_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[13].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY14_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[14].Enabled;
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY15_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Array.ArrayObj->VertexAttrib[15].Enabled;
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[0];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[1];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[2];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[3];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[4];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[5];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[6];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[7];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[8];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[9];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[10];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[11];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[12];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[13];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[14];
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->Eval.Map1Attrib[15];
-+ break;
-+ case GL_FRAGMENT_PROGRAM_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetBooleanv");
-+ params[0] = ctx->FragmentProgram.Enabled;
-+ break;
-+ case GL_FRAGMENT_PROGRAM_BINDING_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0);
-+ break;
-+ case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(MAX_NV_FRAGMENT_PROGRAM_PARAMS);
-+ break;
-+ case GL_TEXTURE_RECTANGLE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-+ params[0] = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
-+ break;
-+ case GL_TEXTURE_BINDING_RECTANGLE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
-+ break;
-+ case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureRectSize);
-+ break;
-+ case GL_STENCIL_TEST_TWO_SIDE_EXT:
-+ CHECK_EXT1(EXT_stencil_two_side, "GetBooleanv");
-+ params[0] = ctx->Stencil.TestTwoSide;
-+ break;
-+ case GL_ACTIVE_STENCIL_FACE_EXT:
-+ CHECK_EXT1(EXT_stencil_two_side, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
-+ break;
-+ case GL_MAX_SHININESS_NV:
-+ CHECK_EXT1(NV_light_max_exponent, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxShininess);
-+ break;
-+ case GL_MAX_SPOT_EXPONENT_NV:
-+ CHECK_EXT1(NV_light_max_exponent, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxSpotExponent);
-+ break;
-+ case GL_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayBufferObj->Name);
-+ break;
-+ case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.BufferObj->Name);
-+ break;
-+ case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.BufferObj->Name);
-+ break;
-+ case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.BufferObj->Name);
-+ break;
-+ case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Index.BufferObj->Name);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.BufferObj->Name);
-+ break;
-+ case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Array.ElementArrayBufferObj->Name);
-+ break;
-+ case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_pixel_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Pack.BufferObj->Name);
-+ break;
-+ case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_pixel_buffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Unpack.BufferObj->Name);
-+ break;
-+ case GL_VERTEX_PROGRAM_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->VertexProgram.Enabled;
-+ break;
-+ case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->VertexProgram.PointSizeEnabled;
-+ break;
-+ case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->VertexProgram.TwoSideEnabled;
-+ break;
-+ case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxProgramMatrixStackDepth);
-+ break;
-+ case GL_MAX_PROGRAM_MATRICES_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxProgramMatrices);
-+ break;
-+ case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetBooleanv");
-+ params[0] = ctx->CurrentStack->Depth + 1;
-+ break;
-+ case GL_CURRENT_MATRIX_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetBooleanv");
-+ {
-+ const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-+ CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetBooleanv");
-+ {
-+ const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+ params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+ params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+ params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+ params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+ params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+ params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+ params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+ params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+ params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+ params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+ params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+ params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+ params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+ params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+ params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+ params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+ }
-+ break;
-+ case GL_MAX_VERTEX_ATTRIBS_ARB:
-+ CHECK_EXT1(ARB_vertex_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.VertexProgram.MaxAttribs);
-+ break;
-+ case GL_PROGRAM_ERROR_POSITION_ARB:
-+ CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Program.ErrorPos);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_ARB:
-+ CHECK_EXT1(ARB_fragment_program, "GetBooleanv");
-+ params[0] = ctx->FragmentProgram.Enabled;
-+ break;
-+ case GL_MAX_TEXTURE_COORDS_ARB:
-+ CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureCoordUnits);
-+ break;
-+ case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureImageUnits);
-+ break;
-+ case GL_DEPTH_BOUNDS_TEST_EXT:
-+ CHECK_EXT1(EXT_depth_bounds_test, "GetBooleanv");
-+ params[0] = ctx->Depth.BoundsTest;
-+ break;
-+ case GL_DEPTH_BOUNDS_EXT:
-+ CHECK_EXT1(EXT_depth_bounds_test, "GetBooleanv");
-+ params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin);
-+ params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+ params[0] = ctx->FragmentProgram.CallbackEnabled;
-+ break;
-+ case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+ params[0] = ctx->VertexProgram.CallbackEnabled;
-+ break;
-+ case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.CurrentPosition);
-+ break;
-+ case GL_VERTEX_PROGRAM_POSITION_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->VertexProgram.CurrentPosition);
-+ break;
-+ case GL_MAX_DRAW_BUFFERS_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers);
-+ break;
-+ case GL_DRAW_BUFFER0_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+ break;
-+ case GL_DRAW_BUFFER1_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
-+ params[0] = ENUM_TO_BOOLEAN(buffer);
-+ }
-+ break;
-+ case GL_DRAW_BUFFER2_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
-+ params[0] = ENUM_TO_BOOLEAN(buffer);
-+ }
-+ break;
-+ case GL_DRAW_BUFFER3_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
-+ params[0] = ENUM_TO_BOOLEAN(buffer);
-+ }
-+ break;
-+ case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-+ CHECK_EXT1(OES_read_format, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.ColorReadType);
-+ break;
-+ case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-+ CHECK_EXT1(OES_read_format, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.ColorReadFormat);
-+ break;
-+ case GL_NUM_FRAGMENT_REGISTERS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(6);
-+ break;
-+ case GL_NUM_FRAGMENT_CONSTANTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(8);
-+ break;
-+ case GL_NUM_PASSES_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(2);
-+ break;
-+ case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(8);
-+ break;
-+ case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(16);
-+ break;
-+ case GL_COLOR_ALPHA_PAIRING_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = GL_TRUE;
-+ break;
-+ case GL_NUM_LOOPBACK_COMPONENTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(3);
-+ break;
-+ case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(3);
-+ break;
-+ case GL_STENCIL_BACK_FUNC:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.Function[1]);
-+ break;
-+ case GL_STENCIL_BACK_VALUE_MASK:
-+ params[0] = INT_TO_BOOLEAN(ctx->Stencil.ValueMask[1]);
-+ break;
-+ case GL_STENCIL_BACK_REF:
-+ params[0] = INT_TO_BOOLEAN(ctx->Stencil.Ref[1]);
-+ break;
-+ case GL_STENCIL_BACK_FAIL:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.FailFunc[1]);
-+ break;
-+ case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZFailFunc[1]);
-+ break;
-+ case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZPassFunc[1]);
-+ break;
-+ case GL_FRAMEBUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Name);
-+ break;
-+ case GL_RENDERBUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0);
-+ break;
-+ case GL_MAX_COLOR_ATTACHMENTS_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxColorAttachments);
-+ break;
-+ case GL_MAX_RENDERBUFFER_SIZE_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(ctx->Const.MaxRenderbufferSize);
-+ break;
-+ case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
-+ CHECK_EXT1(ARB_fragment_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(MAX_FRAGMENT_UNIFORM_COMPONENTS);
-+ break;
-+ case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-+ CHECK_EXT1(ARB_fragment_shader, "GetBooleanv");
-+ params[0] = ENUM_TO_BOOLEAN(ctx->Hint.FragmentShaderDerivative);
-+ break;
-+ case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(MAX_VERTEX_UNIFORM_COMPONENTS);
-+ break;
-+ case GL_MAX_VARYING_FLOATS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(MAX_VARYING_FLOATS);
-+ break;
-+ case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-+ break;
-+ case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+ params[0] = INT_TO_BOOLEAN(MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-+ break;
-+ default:
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv(pname=0x%x)", pname);
-+ }
-+}
-+
-+void GLAPIENTRY
-+_mesa_GetFloatv( GLenum pname, GLfloat *params )
-+{
-+ GET_CURRENT_CONTEXT(ctx);
-+ ASSERT_OUTSIDE_BEGIN_END(ctx);
-+
-+ if (!params)
-+ return;
-+
-+ if (ctx->NewState)
-+ _mesa_update_state(ctx);
-+
-+ if (ctx->Driver.GetFloatv &&
-+ ctx->Driver.GetFloatv(ctx, pname, params))
-+ return;
-+
-+ switch (pname) {
-+ case GL_ACCUM_RED_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumRedBits);
-+ break;
-+ case GL_ACCUM_GREEN_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumGreenBits);
-+ break;
-+ case GL_ACCUM_BLUE_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumBlueBits);
-+ break;
-+ case GL_ACCUM_ALPHA_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumAlphaBits);
-+ break;
-+ case GL_ACCUM_CLEAR_VALUE:
-+ params[0] = ctx->Accum.ClearColor[0];
-+ params[1] = ctx->Accum.ClearColor[1];
-+ params[2] = ctx->Accum.ClearColor[2];
-+ params[3] = ctx->Accum.ClearColor[3];
-+ break;
-+ case GL_ALPHA_BIAS:
-+ params[0] = ctx->Pixel.AlphaBias;
-+ break;
-+ case GL_ALPHA_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.alphaBits);
-+ break;
-+ case GL_ALPHA_SCALE:
-+ params[0] = ctx->Pixel.AlphaScale;
-+ break;
-+ case GL_ALPHA_TEST:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Color.AlphaEnabled);
-+ break;
-+ case GL_ALPHA_TEST_FUNC:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
-+ break;
-+ case GL_ALPHA_TEST_REF:
-+ params[0] = ctx->Color.AlphaRef;
-+ break;
-+ case GL_ATTRIB_STACK_DEPTH:
-+ params[0] = (GLfloat)(ctx->AttribStackDepth);
-+ break;
-+ case GL_AUTO_NORMAL:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.AutoNormal);
-+ break;
-+ case GL_AUX_BUFFERS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.numAuxBuffers);
-+ break;
-+ case GL_BLEND:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Color.BlendEnabled);
-+ break;
-+ case GL_BLEND_DST:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
-+ break;
-+ case GL_BLEND_SRC:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
-+ break;
-+ case GL_BLEND_SRC_RGB_EXT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
-+ break;
-+ case GL_BLEND_DST_RGB_EXT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
-+ break;
-+ case GL_BLEND_SRC_ALPHA_EXT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
-+ break;
-+ case GL_BLEND_DST_ALPHA_EXT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
-+ break;
-+ case GL_BLEND_EQUATION:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendEquationRGB );
-+ break;
-+ case GL_BLEND_EQUATION_ALPHA_EXT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.BlendEquationA );
-+ break;
-+ case GL_BLEND_COLOR_EXT:
-+ params[0] = ctx->Color.BlendColor[0];
-+ params[1] = ctx->Color.BlendColor[1];
-+ params[2] = ctx->Color.BlendColor[2];
-+ params[3] = ctx->Color.BlendColor[3];
-+ break;
-+ case GL_BLUE_BIAS:
-+ params[0] = ctx->Pixel.BlueBias;
-+ break;
-+ case GL_BLUE_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.blueBits);
-+ break;
-+ case GL_BLUE_SCALE:
-+ params[0] = ctx->Pixel.BlueScale;
-+ break;
-+ case GL_CLIENT_ATTRIB_STACK_DEPTH:
-+ params[0] = (GLfloat)(ctx->ClientAttribStackDepth);
-+ break;
-+ case GL_CLIP_PLANE0:
-+ params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
-+ break;
-+ case GL_CLIP_PLANE1:
-+ params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
-+ break;
-+ case GL_CLIP_PLANE2:
-+ params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
-+ break;
-+ case GL_CLIP_PLANE3:
-+ params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
-+ break;
-+ case GL_CLIP_PLANE4:
-+ params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
-+ break;
-+ case GL_CLIP_PLANE5:
-+ params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
-+ break;
-+ case GL_COLOR_CLEAR_VALUE:
-+ params[0] = ctx->Color.ClearColor[0];
-+ params[1] = ctx->Color.ClearColor[1];
-+ params[2] = ctx->Color.ClearColor[2];
-+ params[3] = ctx->Color.ClearColor[3];
-+ break;
-+ case GL_COLOR_MATERIAL:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.ColorMaterialEnabled);
-+ break;
-+ case GL_COLOR_MATERIAL_FACE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
-+ break;
-+ case GL_COLOR_MATERIAL_PARAMETER:
-+ params[0] = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
-+ break;
-+ case GL_COLOR_WRITEMASK:
-+ params[0] = (GLfloat)(ctx->Color.ColorMask[RCOMP] ? 1 : 0);
-+ params[1] = (GLfloat)(ctx->Color.ColorMask[GCOMP] ? 1 : 0);
-+ params[2] = (GLfloat)(ctx->Color.ColorMask[BCOMP] ? 1 : 0);
-+ params[3] = (GLfloat)(ctx->Color.ColorMask[ACOMP] ? 1 : 0);
-+ break;
-+ case GL_CULL_FACE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.CullFlag);
-+ break;
-+ case GL_CULL_FACE_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
-+ break;
-+ case GL_CURRENT_COLOR:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
-+ params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
-+ params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
-+ params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
-+ }
-+ break;
-+ case GL_CURRENT_INDEX:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0];
-+ }
-+ break;
-+ case GL_CURRENT_NORMAL:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
-+ params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
-+ params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
-+ }
-+ break;
-+ case GL_CURRENT_RASTER_COLOR:
-+ params[0] = ctx->Current.RasterColor[0];
-+ params[1] = ctx->Current.RasterColor[1];
-+ params[2] = ctx->Current.RasterColor[2];
-+ params[3] = ctx->Current.RasterColor[3];
-+ break;
-+ case GL_CURRENT_RASTER_DISTANCE:
-+ params[0] = ctx->Current.RasterDistance;
-+ break;
-+ case GL_CURRENT_RASTER_INDEX:
-+ params[0] = ctx->Current.RasterIndex;
-+ break;
-+ case GL_CURRENT_RASTER_POSITION:
-+ params[0] = ctx->Current.RasterPos[0];
-+ params[1] = ctx->Current.RasterPos[1];
-+ params[2] = ctx->Current.RasterPos[2];
-+ params[3] = ctx->Current.RasterPos[3];
-+ break;
-+ case GL_CURRENT_RASTER_SECONDARY_COLOR:
-+ params[0] = ctx->Current.RasterSecondaryColor[0];
-+ params[1] = ctx->Current.RasterSecondaryColor[1];
-+ params[2] = ctx->Current.RasterSecondaryColor[2];
-+ params[3] = ctx->Current.RasterSecondaryColor[3];
-+ break;
-+ case GL_CURRENT_RASTER_TEXTURE_COORDS:
-+ {
-+ const GLuint texUnit = ctx->Texture.CurrentUnit;
-+ params[0] = ctx->Current.RasterTexCoords[texUnit][0];
-+ params[1] = ctx->Current.RasterTexCoords[texUnit][1];
-+ params[2] = ctx->Current.RasterTexCoords[texUnit][2];
-+ params[3] = ctx->Current.RasterTexCoords[texUnit][3];
-+ }
-+ break;
-+ case GL_CURRENT_RASTER_POSITION_VALID:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Current.RasterPosValid);
-+ break;
-+ case GL_CURRENT_TEXTURE_COORDS:
-+ {
-+ const GLuint texUnit = ctx->Texture.CurrentUnit;
-+ params[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
-+ params[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
-+ params[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
-+ params[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
-+ }
-+ break;
-+ case GL_DEPTH_BIAS:
-+ params[0] = ctx->Pixel.DepthBias;
-+ break;
-+ case GL_DEPTH_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.depthBits);
-+ break;
-+ case GL_DEPTH_CLEAR_VALUE:
-+ params[0] = ctx->Depth.Clear;
-+ break;
-+ case GL_DEPTH_FUNC:
-+ params[0] = ENUM_TO_FLOAT(ctx->Depth.Func);
-+ break;
-+ case GL_DEPTH_RANGE:
-+ params[0] = ctx->Viewport.Near;
-+ params[1] = ctx->Viewport.Far;
-+ break;
-+ case GL_DEPTH_SCALE:
-+ params[0] = ctx->Pixel.DepthScale;
-+ break;
-+ case GL_DEPTH_TEST:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.Test);
-+ break;
-+ case GL_DEPTH_WRITEMASK:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.Mask);
-+ break;
-+ case GL_DITHER:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Color.DitherFlag);
-+ break;
-+ case GL_DOUBLEBUFFER:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->DrawBuffer->Visual.doubleBufferMode);
-+ break;
-+ case GL_DRAW_BUFFER:
-+ params[0] = ENUM_TO_FLOAT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+ break;
-+ case GL_EDGE_FLAG:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Current.EdgeFlag);
-+ }
-+ break;
-+ case GL_FEEDBACK_BUFFER_SIZE:
-+ params[0] = (GLfloat)(ctx->Feedback.BufferSize);
-+ break;
-+ case GL_FEEDBACK_BUFFER_TYPE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Feedback.Type);
-+ break;
-+ case GL_FOG:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Fog.Enabled);
-+ break;
-+ case GL_FOG_COLOR:
-+ params[0] = ctx->Fog.Color[0];
-+ params[1] = ctx->Fog.Color[1];
-+ params[2] = ctx->Fog.Color[2];
-+ params[3] = ctx->Fog.Color[3];
-+ break;
-+ case GL_FOG_DENSITY:
-+ params[0] = ctx->Fog.Density;
-+ break;
-+ case GL_FOG_END:
-+ params[0] = ctx->Fog.End;
-+ break;
-+ case GL_FOG_HINT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.Fog);
-+ break;
-+ case GL_FOG_INDEX:
-+ params[0] = ctx->Fog.Index;
-+ break;
-+ case GL_FOG_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Fog.Mode);
-+ break;
-+ case GL_FOG_START:
-+ params[0] = ctx->Fog.Start;
-+ break;
-+ case GL_FRONT_FACE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
-+ break;
-+ case GL_GREEN_BIAS:
-+ params[0] = ctx->Pixel.GreenBias;
-+ break;
-+ case GL_GREEN_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.greenBits);
-+ break;
-+ case GL_GREEN_SCALE:
-+ params[0] = ctx->Pixel.GreenScale;
-+ break;
-+ case GL_INDEX_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.indexBits);
-+ break;
-+ case GL_INDEX_CLEAR_VALUE:
-+ params[0] = (GLfloat)(ctx->Color.ClearIndex);
-+ break;
-+ case GL_INDEX_MODE:
-+ params[0] = BOOLEAN_TO_FLOAT(!ctx->DrawBuffer->Visual.rgbMode);
-+ break;
-+ case GL_INDEX_OFFSET:
-+ params[0] = (GLfloat)(ctx->Pixel.IndexOffset);
-+ break;
-+ case GL_INDEX_SHIFT:
-+ params[0] = (GLfloat)(ctx->Pixel.IndexShift);
-+ break;
-+ case GL_INDEX_WRITEMASK:
-+ params[0] = (GLfloat)(ctx->Color.IndexMask);
-+ break;
-+ case GL_LIGHT0:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[0].Enabled);
-+ break;
-+ case GL_LIGHT1:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[1].Enabled);
-+ break;
-+ case GL_LIGHT2:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[2].Enabled);
-+ break;
-+ case GL_LIGHT3:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[3].Enabled);
-+ break;
-+ case GL_LIGHT4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[4].Enabled);
-+ break;
-+ case GL_LIGHT5:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[5].Enabled);
-+ break;
-+ case GL_LIGHT6:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[6].Enabled);
-+ break;
-+ case GL_LIGHT7:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[7].Enabled);
-+ break;
-+ case GL_LIGHTING:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Enabled);
-+ break;
-+ case GL_LIGHT_MODEL_AMBIENT:
-+ params[0] = ctx->Light.Model.Ambient[0];
-+ params[1] = ctx->Light.Model.Ambient[1];
-+ params[2] = ctx->Light.Model.Ambient[2];
-+ params[3] = ctx->Light.Model.Ambient[3];
-+ break;
-+ case GL_LIGHT_MODEL_COLOR_CONTROL:
-+ params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
-+ break;
-+ case GL_LIGHT_MODEL_LOCAL_VIEWER:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Model.LocalViewer);
-+ break;
-+ case GL_LIGHT_MODEL_TWO_SIDE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Model.TwoSide);
-+ break;
-+ case GL_LINE_SMOOTH:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Line.SmoothFlag);
-+ break;
-+ case GL_LINE_SMOOTH_HINT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
-+ break;
-+ case GL_LINE_STIPPLE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Line.StippleFlag);
-+ break;
-+ case GL_LINE_STIPPLE_PATTERN:
-+ params[0] = (GLfloat)(ctx->Line.StipplePattern);
-+ break;
-+ case GL_LINE_STIPPLE_REPEAT:
-+ params[0] = (GLfloat)(ctx->Line.StippleFactor);
-+ break;
-+ case GL_LINE_WIDTH:
-+ params[0] = ctx->Line.Width;
-+ break;
-+ case GL_LINE_WIDTH_GRANULARITY:
-+ params[0] = ctx->Const.LineWidthGranularity;
-+ break;
-+ case GL_LINE_WIDTH_RANGE:
-+ params[0] = ctx->Const.MinLineWidthAA;
-+ params[1] = ctx->Const.MaxLineWidthAA;
-+ break;
-+ case GL_ALIASED_LINE_WIDTH_RANGE:
-+ params[0] = ctx->Const.MinLineWidth;
-+ params[1] = ctx->Const.MaxLineWidth;
-+ break;
-+ case GL_LIST_BASE:
-+ params[0] = (GLfloat)(ctx->List.ListBase);
-+ break;
-+ case GL_LIST_INDEX:
-+ params[0] = (GLfloat)(ctx->ListState.CurrentListNum);
-+ break;
-+ case GL_LIST_MODE:
-+ {
-+ GLenum mode;
-+ if (!ctx->CompileFlag)
-+ mode = 0;
-+ else if (ctx->ExecuteFlag)
-+ mode = GL_COMPILE_AND_EXECUTE;
-+ else
-+ mode = GL_COMPILE;
-+ params[0] = ENUM_TO_FLOAT(mode);
-+ }
-+ break;
-+ case GL_INDEX_LOGIC_OP:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Color.IndexLogicOpEnabled);
-+ break;
-+ case GL_COLOR_LOGIC_OP:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Color.ColorLogicOpEnabled);
-+ break;
-+ case GL_LOGIC_OP_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Color.LogicOp);
-+ break;
-+ case GL_MAP1_COLOR_4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Color4);
-+ break;
-+ case GL_MAP1_GRID_DOMAIN:
-+ params[0] = ctx->Eval.MapGrid1u1;
-+ params[1] = ctx->Eval.MapGrid1u2;
-+ break;
-+ case GL_MAP1_GRID_SEGMENTS:
-+ params[0] = (GLfloat)(ctx->Eval.MapGrid1un);
-+ break;
-+ case GL_MAP1_INDEX:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Index);
-+ break;
-+ case GL_MAP1_NORMAL:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Normal);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_1:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord1);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_2:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord2);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_3:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord3);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord4);
-+ break;
-+ case GL_MAP1_VERTEX_3:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Vertex3);
-+ break;
-+ case GL_MAP1_VERTEX_4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Vertex4);
-+ break;
-+ case GL_MAP2_COLOR_4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Color4);
-+ break;
-+ case GL_MAP2_GRID_DOMAIN:
-+ params[0] = ctx->Eval.MapGrid2u1;
-+ params[1] = ctx->Eval.MapGrid2u2;
-+ params[2] = ctx->Eval.MapGrid2v1;
-+ params[3] = ctx->Eval.MapGrid2v2;
-+ break;
-+ case GL_MAP2_GRID_SEGMENTS:
-+ params[0] = (GLfloat)(ctx->Eval.MapGrid2un);
-+ params[1] = (GLfloat)(ctx->Eval.MapGrid2vn);
-+ break;
-+ case GL_MAP2_INDEX:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Index);
-+ break;
-+ case GL_MAP2_NORMAL:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Normal);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_1:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord1);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_2:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord2);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_3:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord3);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord4);
-+ break;
-+ case GL_MAP2_VERTEX_3:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Vertex3);
-+ break;
-+ case GL_MAP2_VERTEX_4:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Vertex4);
-+ break;
-+ case GL_MAP_COLOR:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MapColorFlag);
-+ break;
-+ case GL_MAP_STENCIL:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MapStencilFlag);
-+ break;
-+ case GL_MATRIX_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
-+ break;
-+ case GL_MAX_ATTRIB_STACK_DEPTH:
-+ params[0] = (GLfloat)(MAX_ATTRIB_STACK_DEPTH);
-+ break;
-+ case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-+ params[0] = (GLfloat)(MAX_CLIENT_ATTRIB_STACK_DEPTH);
-+ break;
-+ case GL_MAX_CLIP_PLANES:
-+ params[0] = (GLfloat)(ctx->Const.MaxClipPlanes);
-+ break;
-+ case GL_MAX_ELEMENTS_VERTICES:
-+ params[0] = (GLfloat)(ctx->Const.MaxArrayLockSize);
-+ break;
-+ case GL_MAX_ELEMENTS_INDICES:
-+ params[0] = (GLfloat)(ctx->Const.MaxArrayLockSize);
-+ break;
-+ case GL_MAX_EVAL_ORDER:
-+ params[0] = (GLfloat)(MAX_EVAL_ORDER);
-+ break;
-+ case GL_MAX_LIGHTS:
-+ params[0] = (GLfloat)(ctx->Const.MaxLights);
-+ break;
-+ case GL_MAX_LIST_NESTING:
-+ params[0] = (GLfloat)(MAX_LIST_NESTING);
-+ break;
-+ case GL_MAX_MODELVIEW_STACK_DEPTH:
-+ params[0] = (GLfloat)(MAX_MODELVIEW_STACK_DEPTH);
-+ break;
-+ case GL_MAX_NAME_STACK_DEPTH:
-+ params[0] = (GLfloat)(MAX_NAME_STACK_DEPTH);
-+ break;
-+ case GL_MAX_PIXEL_MAP_TABLE:
-+ params[0] = (GLfloat)(MAX_PIXEL_MAP_TABLE);
-+ break;
-+ case GL_MAX_PROJECTION_STACK_DEPTH:
-+ params[0] = (GLfloat)(MAX_PROJECTION_STACK_DEPTH);
-+ break;
-+ case GL_MAX_TEXTURE_SIZE:
-+ params[0] = (GLfloat)(1 << (ctx->Const.MaxTextureLevels - 1));
-+ break;
-+ case GL_MAX_3D_TEXTURE_SIZE:
-+ params[0] = (GLfloat)(1 << (ctx->Const.Max3DTextureLevels - 1));
-+ break;
-+ case GL_MAX_TEXTURE_STACK_DEPTH:
-+ params[0] = (GLfloat)(MAX_TEXTURE_STACK_DEPTH);
-+ break;
-+ case GL_MAX_VIEWPORT_DIMS:
-+ params[0] = (GLfloat)(ctx->Const.MaxViewportWidth);
-+ params[1] = (GLfloat)(ctx->Const.MaxViewportHeight);
-+ break;
-+ case GL_MODELVIEW_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[1];
-+ params[2] = matrix[2];
-+ params[3] = matrix[3];
-+ params[4] = matrix[4];
-+ params[5] = matrix[5];
-+ params[6] = matrix[6];
-+ params[7] = matrix[7];
-+ params[8] = matrix[8];
-+ params[9] = matrix[9];
-+ params[10] = matrix[10];
-+ params[11] = matrix[11];
-+ params[12] = matrix[12];
-+ params[13] = matrix[13];
-+ params[14] = matrix[14];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_MODELVIEW_STACK_DEPTH:
-+ params[0] = (GLfloat)(ctx->ModelviewMatrixStack.Depth + 1);
-+ break;
-+ case GL_NAME_STACK_DEPTH:
-+ params[0] = (GLfloat)(ctx->Select.NameStackDepth);
-+ break;
-+ case GL_NORMALIZE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.Normalize);
-+ break;
-+ case GL_PACK_ALIGNMENT:
-+ params[0] = (GLfloat)(ctx->Pack.Alignment);
-+ break;
-+ case GL_PACK_LSB_FIRST:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.LsbFirst);
-+ break;
-+ case GL_PACK_ROW_LENGTH:
-+ params[0] = (GLfloat)(ctx->Pack.RowLength);
-+ break;
-+ case GL_PACK_SKIP_PIXELS:
-+ params[0] = (GLfloat)(ctx->Pack.SkipPixels);
-+ break;
-+ case GL_PACK_SKIP_ROWS:
-+ params[0] = (GLfloat)(ctx->Pack.SkipRows);
-+ break;
-+ case GL_PACK_SWAP_BYTES:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.SwapBytes);
-+ break;
-+ case GL_PACK_SKIP_IMAGES_EXT:
-+ params[0] = (GLfloat)(ctx->Pack.SkipImages);
-+ break;
-+ case GL_PACK_IMAGE_HEIGHT_EXT:
-+ params[0] = (GLfloat)(ctx->Pack.ImageHeight);
-+ break;
-+ case GL_PACK_INVERT_MESA:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.Invert);
-+ break;
-+ case GL_PERSPECTIVE_CORRECTION_HINT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
-+ break;
-+ case GL_PIXEL_MAP_A_TO_A_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapAtoAsize);
-+ break;
-+ case GL_PIXEL_MAP_B_TO_B_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapBtoBsize);
-+ break;
-+ case GL_PIXEL_MAP_G_TO_G_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapGtoGsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_A_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapItoAsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_B_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapItoBsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_G_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapItoGsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_I_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapItoIsize);
-+ break;
-+ case GL_PIXEL_MAP_I_TO_R_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapItoRsize);
-+ break;
-+ case GL_PIXEL_MAP_R_TO_R_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapRtoRsize);
-+ break;
-+ case GL_PIXEL_MAP_S_TO_S_SIZE:
-+ params[0] = (GLfloat)(ctx->Pixel.MapStoSsize);
-+ break;
-+ case GL_POINT_SIZE:
-+ params[0] = ctx->Point.Size;
-+ break;
-+ case GL_POINT_SIZE_GRANULARITY:
-+ params[0] = ctx->Const.PointSizeGranularity;
-+ break;
-+ case GL_POINT_SIZE_RANGE:
-+ params[0] = ctx->Const.MinPointSizeAA;
-+ params[1] = ctx->Const.MaxPointSizeAA;
-+ break;
-+ case GL_ALIASED_POINT_SIZE_RANGE:
-+ params[0] = ctx->Const.MinPointSize;
-+ params[1] = ctx->Const.MaxPointSize;
-+ break;
-+ case GL_POINT_SMOOTH:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Point.SmoothFlag);
-+ break;
-+ case GL_POINT_SMOOTH_HINT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
-+ break;
-+ case GL_POINT_SIZE_MIN_EXT:
-+ params[0] = ctx->Point.MinSize;
-+ break;
-+ case GL_POINT_SIZE_MAX_EXT:
-+ params[0] = ctx->Point.MaxSize;
-+ break;
-+ case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
-+ params[0] = ctx->Point.Threshold;
-+ break;
-+ case GL_DISTANCE_ATTENUATION_EXT:
-+ params[0] = ctx->Point.Params[0];
-+ params[1] = ctx->Point.Params[1];
-+ params[2] = ctx->Point.Params[2];
-+ break;
-+ case GL_POLYGON_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
-+ params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
-+ break;
-+ case GL_POLYGON_OFFSET_BIAS_EXT:
-+ params[0] = ctx->Polygon.OffsetUnits;
-+ break;
-+ case GL_POLYGON_OFFSET_FACTOR:
-+ params[0] = ctx->Polygon.OffsetFactor ;
-+ break;
-+ case GL_POLYGON_OFFSET_UNITS:
-+ params[0] = ctx->Polygon.OffsetUnits ;
-+ break;
-+ case GL_POLYGON_SMOOTH:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.SmoothFlag);
-+ break;
-+ case GL_POLYGON_SMOOTH_HINT:
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
-+ break;
-+ case GL_POLYGON_STIPPLE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.StippleFlag);
-+ break;
-+ case GL_PROJECTION_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[1];
-+ params[2] = matrix[2];
-+ params[3] = matrix[3];
-+ params[4] = matrix[4];
-+ params[5] = matrix[5];
-+ params[6] = matrix[6];
-+ params[7] = matrix[7];
-+ params[8] = matrix[8];
-+ params[9] = matrix[9];
-+ params[10] = matrix[10];
-+ params[11] = matrix[11];
-+ params[12] = matrix[12];
-+ params[13] = matrix[13];
-+ params[14] = matrix[14];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_PROJECTION_STACK_DEPTH:
-+ params[0] = (GLfloat)(ctx->ProjectionMatrixStack.Depth + 1);
-+ break;
-+ case GL_READ_BUFFER:
-+ params[0] = ENUM_TO_FLOAT(ctx->ReadBuffer->ColorReadBuffer);
-+ break;
-+ case GL_RED_BIAS:
-+ params[0] = ctx->Pixel.RedBias;
-+ break;
-+ case GL_RED_BITS:
-+ params[0] = (GLfloat)( ctx->DrawBuffer->Visual.redBits );
-+ break;
-+ case GL_RED_SCALE:
-+ params[0] = ctx->Pixel.RedScale;
-+ break;
-+ case GL_RENDER_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->RenderMode);
-+ break;
-+ case GL_RESCALE_NORMAL:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.RescaleNormals);
-+ break;
-+ case GL_RGBA_MODE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->DrawBuffer->Visual.rgbMode);
-+ break;
-+ case GL_SCISSOR_BOX:
-+ params[0] = (GLfloat)(ctx->Scissor.X);
-+ params[1] = (GLfloat)(ctx->Scissor.Y);
-+ params[2] = (GLfloat)(ctx->Scissor.Width);
-+ params[3] = (GLfloat)(ctx->Scissor.Height);
-+ break;
-+ case GL_SCISSOR_TEST:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Scissor.Enabled);
-+ break;
-+ case GL_SELECTION_BUFFER_SIZE:
-+ params[0] = (GLfloat)(ctx->Select.BufferSize);
-+ break;
-+ case GL_SHADE_MODEL:
-+ params[0] = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
-+ break;
-+ case GL_SHARED_TEXTURE_PALETTE_EXT:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.SharedPalette);
-+ break;
-+ case GL_STENCIL_BITS:
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.stencilBits);
-+ break;
-+ case GL_STENCIL_CLEAR_VALUE:
-+ params[0] = (GLfloat)(ctx->Stencil.Clear);
-+ break;
-+ case GL_STENCIL_FAIL:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_FUNC:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_PASS_DEPTH_FAIL:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_PASS_DEPTH_PASS:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_REF:
-+ params[0] = (GLfloat)(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_TEST:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Stencil.Enabled);
-+ break;
-+ case GL_STENCIL_VALUE_MASK:
-+ params[0] = (GLfloat)(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_WRITEMASK:
-+ params[0] = (GLfloat)(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STEREO:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->DrawBuffer->Visual.stereoMode);
-+ break;
-+ case GL_SUBPIXEL_BITS:
-+ params[0] = (GLfloat)(ctx->Const.SubPixelBits);
-+ break;
-+ case GL_TEXTURE_1D:
-+ params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_1D));
-+ break;
-+ case GL_TEXTURE_2D:
-+ params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_2D));
-+ break;
-+ case GL_TEXTURE_3D:
-+ params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_3D));
-+ break;
-+ case GL_TEXTURE_BINDING_1D:
-+ params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
-+ break;
-+ case GL_TEXTURE_BINDING_2D:
-+ params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
-+ break;
-+ case GL_TEXTURE_BINDING_3D:
-+ params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
-+ break;
-+ case GL_TEXTURE_ENV_COLOR:
-+ {
-+ const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
-+ params[0] = color[0];
-+ params[1] = color[1];
-+ params[2] = color[2];
-+ params[3] = color[3];
-+ }
-+ break;
-+ case GL_TEXTURE_ENV_MODE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
-+ break;
-+ case GL_TEXTURE_GEN_S:
-+ params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_GEN_T:
-+ params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_GEN_R:
-+ params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_GEN_Q:
-+ params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[1];
-+ params[2] = matrix[2];
-+ params[3] = matrix[3];
-+ params[4] = matrix[4];
-+ params[5] = matrix[5];
-+ params[6] = matrix[6];
-+ params[7] = matrix[7];
-+ params[8] = matrix[8];
-+ params[9] = matrix[9];
-+ params[10] = matrix[10];
-+ params[11] = matrix[11];
-+ params[12] = matrix[12];
-+ params[13] = matrix[13];
-+ params[14] = matrix[14];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_TEXTURE_STACK_DEPTH:
-+ params[0] = (GLfloat)(ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1);
-+ break;
-+ case GL_UNPACK_ALIGNMENT:
-+ params[0] = (GLfloat)(ctx->Unpack.Alignment);
-+ break;
-+ case GL_UNPACK_LSB_FIRST:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.LsbFirst);
-+ break;
-+ case GL_UNPACK_ROW_LENGTH:
-+ params[0] = (GLfloat)(ctx->Unpack.RowLength);
-+ break;
-+ case GL_UNPACK_SKIP_PIXELS:
-+ params[0] = (GLfloat)(ctx->Unpack.SkipPixels);
-+ break;
-+ case GL_UNPACK_SKIP_ROWS:
-+ params[0] = (GLfloat)(ctx->Unpack.SkipRows);
-+ break;
-+ case GL_UNPACK_SWAP_BYTES:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.SwapBytes);
-+ break;
-+ case GL_UNPACK_SKIP_IMAGES_EXT:
-+ params[0] = (GLfloat)(ctx->Unpack.SkipImages);
-+ break;
-+ case GL_UNPACK_IMAGE_HEIGHT_EXT:
-+ params[0] = (GLfloat)(ctx->Unpack.ImageHeight);
-+ break;
-+ case GL_UNPACK_CLIENT_STORAGE_APPLE:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.ClientStorage);
-+ break;
-+ case GL_VIEWPORT:
-+ params[0] = (GLfloat)(ctx->Viewport.X);
-+ params[1] = (GLfloat)(ctx->Viewport.Y);
-+ params[2] = (GLfloat)(ctx->Viewport.Width);
-+ params[3] = (GLfloat)(ctx->Viewport.Height);
-+ break;
-+ case GL_ZOOM_X:
-+ params[0] = ctx->Pixel.ZoomX;
-+ break;
-+ case GL_ZOOM_Y:
-+ params[0] = ctx->Pixel.ZoomY;
-+ break;
-+ case GL_VERTEX_ARRAY:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->Vertex.Enabled);
-+ break;
-+ case GL_VERTEX_ARRAY_SIZE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.Size);
-+ break;
-+ case GL_VERTEX_ARRAY_TYPE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Vertex.Type);
-+ break;
-+ case GL_VERTEX_ARRAY_STRIDE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.Stride);
-+ break;
-+ case GL_VERTEX_ARRAY_COUNT_EXT:
-+ params[0] = (GLfloat)(0);
-+ break;
-+ case GL_NORMAL_ARRAY:
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Normal.Enabled);
-+ break;
-+ case GL_NORMAL_ARRAY_TYPE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Normal.Type);
-+ break;
-+ case GL_NORMAL_ARRAY_STRIDE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Normal.Stride);
-+ break;
-+ case GL_NORMAL_ARRAY_COUNT_EXT:
-+ params[0] = (GLfloat)(0);
-+ break;
-+ case GL_COLOR_ARRAY:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->Color.Enabled);
-+ break;
-+ case GL_COLOR_ARRAY_SIZE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.Size);
-+ break;
-+ case GL_COLOR_ARRAY_TYPE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Color.Type);
-+ break;
-+ case GL_COLOR_ARRAY_STRIDE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.Stride);
-+ break;
-+ case GL_COLOR_ARRAY_COUNT_EXT:
-+ params[0] = (GLfloat)(0);
-+ break;
-+ case GL_INDEX_ARRAY:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->Index.Enabled);
-+ break;
-+ case GL_INDEX_ARRAY_TYPE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Index.Type);
-+ break;
-+ case GL_INDEX_ARRAY_STRIDE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Index.Stride);
-+ break;
-+ case GL_INDEX_ARRAY_COUNT_EXT:
-+ params[0] = (GLfloat)(0);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_SIZE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_TYPE:
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
-+ params[0] = (GLfloat)(0);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY:
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->EdgeFlag.Enabled);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_STRIDE:
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->EdgeFlag.Stride);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
-+ params[0] = (GLfloat)(0);
-+ break;
-+ case GL_MAX_TEXTURE_UNITS_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxTextureUnits);
-+ break;
-+ case GL_ACTIVE_TEXTURE_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetFloatv");
-+ params[0] = (GLfloat)(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
-+ break;
-+ case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetFloatv");
-+ params[0] = (GLfloat)(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
-+ break;
-+ case GL_TEXTURE_CUBE_MAP_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
-+ break;
-+ case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
-+ break;
-+ case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-+ params[0] = (GLfloat)((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
-+ break;
-+ case GL_TEXTURE_COMPRESSION_HINT_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Hint.TextureCompression);
-+ break;
-+ case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetFloatv");
-+ params[0] = (GLfloat)(_mesa_get_compressed_formats(ctx, NULL, GL_FALSE));
-+ break;
-+ case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetFloatv");
-+ {
-+ GLint formats[100];
-+ GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
-+ ASSERT(n <= 100);
-+ for (i = 0; i < n; i++)
-+ params[i] = ENUM_TO_INT(formats[i]);
-+ }
-+ break;
-+ case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-+ CHECK_EXT1(EXT_compiled_vertex_array, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.LockFirst);
-+ break;
-+ case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-+ CHECK_EXT1(EXT_compiled_vertex_array, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.LockCount);
-+ break;
-+ case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[4];
-+ params[2] = matrix[8];
-+ params[3] = matrix[12];
-+ params[4] = matrix[1];
-+ params[5] = matrix[5];
-+ params[6] = matrix[9];
-+ params[7] = matrix[13];
-+ params[8] = matrix[2];
-+ params[9] = matrix[6];
-+ params[10] = matrix[10];
-+ params[11] = matrix[14];
-+ params[12] = matrix[3];
-+ params[13] = matrix[7];
-+ params[14] = matrix[11];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[4];
-+ params[2] = matrix[8];
-+ params[3] = matrix[12];
-+ params[4] = matrix[1];
-+ params[5] = matrix[5];
-+ params[6] = matrix[9];
-+ params[7] = matrix[13];
-+ params[8] = matrix[2];
-+ params[9] = matrix[6];
-+ params[10] = matrix[10];
-+ params[11] = matrix[14];
-+ params[12] = matrix[3];
-+ params[13] = matrix[7];
-+ params[14] = matrix[11];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[4];
-+ params[2] = matrix[8];
-+ params[3] = matrix[12];
-+ params[4] = matrix[1];
-+ params[5] = matrix[5];
-+ params[6] = matrix[9];
-+ params[7] = matrix[13];
-+ params[8] = matrix[2];
-+ params[9] = matrix[6];
-+ params[10] = matrix[10];
-+ params[11] = matrix[14];
-+ params[12] = matrix[3];
-+ params[13] = matrix[7];
-+ params[14] = matrix[11];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[4];
-+ params[2] = matrix[8];
-+ params[3] = matrix[12];
-+ params[4] = matrix[1];
-+ params[5] = matrix[5];
-+ params[6] = matrix[9];
-+ params[7] = matrix[13];
-+ params[8] = matrix[2];
-+ params[9] = matrix[6];
-+ params[10] = matrix[10];
-+ params[11] = matrix[14];
-+ params[12] = matrix[3];
-+ params[13] = matrix[7];
-+ params[14] = matrix[11];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_COLOR_MATRIX_SGI:
-+ {
-+ const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[1];
-+ params[2] = matrix[2];
-+ params[3] = matrix[3];
-+ params[4] = matrix[4];
-+ params[5] = matrix[5];
-+ params[6] = matrix[6];
-+ params[7] = matrix[7];
-+ params[8] = matrix[8];
-+ params[9] = matrix[9];
-+ params[10] = matrix[10];
-+ params[11] = matrix[11];
-+ params[12] = matrix[12];
-+ params[13] = matrix[13];
-+ params[14] = matrix[14];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-+ params[0] = (GLfloat)(ctx->ColorMatrixStack.Depth + 1);
-+ break;
-+ case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
-+ params[0] = (GLfloat)(MAX_COLOR_STACK_DEPTH);
-+ break;
-+ case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixScale[0];
-+ break;
-+ case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixScale[1];
-+ break;
-+ case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixScale[2];
-+ break;
-+ case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixScale[3];
-+ break;
-+ case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixBias[0];
-+ break;
-+ case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixBias[1];
-+ break;
-+ case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixBias[2];
-+ break;
-+ case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
-+ params[0] = ctx->Pixel.PostColorMatrixBias[3];
-+ break;
-+ case GL_CONVOLUTION_1D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Convolution1DEnabled);
-+ break;
-+ case GL_CONVOLUTION_2D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Convolution2DEnabled);
-+ break;
-+ case GL_SEPARABLE_2D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Separable2DEnabled);
-+ break;
-+ case GL_POST_CONVOLUTION_RED_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionScale[0];
-+ break;
-+ case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionScale[1];
-+ break;
-+ case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionScale[2];
-+ break;
-+ case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionScale[3];
-+ break;
-+ case GL_POST_CONVOLUTION_RED_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionBias[0];
-+ break;
-+ case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionBias[1];
-+ break;
-+ case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionBias[2];
-+ break;
-+ case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetFloatv");
-+ params[0] = ctx->Pixel.PostConvolutionBias[3];
-+ break;
-+ case GL_HISTOGRAM:
-+ CHECK_EXT1(EXT_histogram, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.HistogramEnabled);
-+ break;
-+ case GL_MINMAX:
-+ CHECK_EXT1(EXT_histogram, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MinMaxEnabled);
-+ break;
-+ case GL_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.ColorTableEnabled);
-+ break;
-+ case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PostConvolutionColorTableEnabled);
-+ break;
-+ case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PostColorMatrixColorTableEnabled);
-+ break;
-+ case GL_TEXTURE_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_texture_color_table, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
-+ break;
-+ case GL_COLOR_SUM_EXT:
-+ CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Fog.ColorSumEnabled);
-+ break;
-+ case GL_CURRENT_SECONDARY_COLOR_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
-+ params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
-+ params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
-+ params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3];
-+ }
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->SecondaryColor.Enabled);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->SecondaryColor.Type);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.Stride);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.Size);
-+ break;
-+ case GL_CURRENT_FOG_COORDINATE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
-+ }
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->FogCoord.Enabled);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->FogCoord.Type);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->FogCoord.Stride);
-+ break;
-+ case GL_FOG_COORDINATE_SOURCE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Fog.FogCoordinateSource);
-+ break;
-+ case GL_MAX_TEXTURE_LOD_BIAS_EXT:
-+ CHECK_EXT1(EXT_texture_lod_bias, "GetFloatv");
-+ params[0] = ctx->Const.MaxTextureLodBias;
-+ break;
-+ case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-+ CHECK_EXT1(EXT_texture_filter_anisotropic, "GetFloatv");
-+ params[0] = ctx->Const.MaxTextureMaxAnisotropy;
-+ break;
-+ case GL_MULTISAMPLE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.Enabled);
-+ break;
-+ case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToCoverage);
-+ break;
-+ case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToOne);
-+ break;
-+ case GL_SAMPLE_COVERAGE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverage);
-+ break;
-+ case GL_SAMPLE_COVERAGE_VALUE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = ctx->Multisample.SampleCoverageValue;
-+ break;
-+ case GL_SAMPLE_COVERAGE_INVERT_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverageInvert);
-+ break;
-+ case GL_SAMPLE_BUFFERS_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.sampleBuffers);
-+ break;
-+ case GL_SAMPLES_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Visual.samples);
-+ break;
-+ case GL_RASTER_POSITION_UNCLIPPED_IBM:
-+ CHECK_EXT1(IBM_rasterpos_clip, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.RasterPositionUnclipped);
-+ break;
-+ case GL_POINT_SPRITE_NV:
-+ CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Point.PointSprite);
-+ break;
-+ case GL_POINT_SPRITE_R_MODE_NV:
-+ CHECK_EXT1(NV_point_sprite, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Point.SpriteRMode);
-+ break;
-+ case GL_POINT_SPRITE_COORD_ORIGIN:
-+ CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Point.SpriteOrigin);
-+ break;
-+ case GL_GENERATE_MIPMAP_HINT_SGIS:
-+ CHECK_EXT1(SGIS_generate_mipmap, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.GenerateMipmap);
-+ break;
-+ case GL_VERTEX_PROGRAM_BINDING_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = (GLfloat)((ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0));
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY0_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY1_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[1].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY2_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[2].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY3_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[3].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[4].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY5_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[5].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY6_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[6].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY7_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[7].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY8_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[8].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY9_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[9].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY10_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[10].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY11_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[11].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY12_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[12].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY13_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[13].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY14_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[14].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY15_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[15].Enabled);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[0]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[1]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[2]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[3]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[4]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[5]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[6]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[7]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[8]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[9]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[10]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[11]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[12]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[13]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[14]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[15]);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.Enabled);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_BINDING_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0);
-+ break;
-+ case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetFloatv");
-+ params[0] = (GLfloat)(MAX_NV_FRAGMENT_PROGRAM_PARAMS);
-+ break;
-+ case GL_TEXTURE_RECTANGLE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
-+ break;
-+ case GL_TEXTURE_BINDING_RECTANGLE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
-+ break;
-+ case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxTextureRectSize);
-+ break;
-+ case GL_STENCIL_TEST_TWO_SIDE_EXT:
-+ CHECK_EXT1(EXT_stencil_two_side, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Stencil.TestTwoSide);
-+ break;
-+ case GL_ACTIVE_STENCIL_FACE_EXT:
-+ CHECK_EXT1(EXT_stencil_two_side, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
-+ break;
-+ case GL_MAX_SHININESS_NV:
-+ CHECK_EXT1(NV_light_max_exponent, "GetFloatv");
-+ params[0] = ctx->Const.MaxShininess;
-+ break;
-+ case GL_MAX_SPOT_EXPONENT_NV:
-+ CHECK_EXT1(NV_light_max_exponent, "GetFloatv");
-+ params[0] = ctx->Const.MaxSpotExponent;
-+ break;
-+ case GL_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayBufferObj->Name);
-+ break;
-+ case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.BufferObj->Name);
-+ break;
-+ case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Normal.BufferObj->Name);
-+ break;
-+ case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.BufferObj->Name);
-+ break;
-+ case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->Index.BufferObj->Name);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ArrayObj->FogCoord.BufferObj->Name);
-+ break;
-+ case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Array.ElementArrayBufferObj->Name);
-+ break;
-+ case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_pixel_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Pack.BufferObj->Name);
-+ break;
-+ case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_pixel_buffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Unpack.BufferObj->Name);
-+ break;
-+ case GL_VERTEX_PROGRAM_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.Enabled);
-+ break;
-+ case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.PointSizeEnabled);
-+ break;
-+ case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.TwoSideEnabled);
-+ break;
-+ case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxProgramMatrixStackDepth);
-+ break;
-+ case GL_MAX_PROGRAM_MATRICES_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxProgramMatrices);
-+ break;
-+ case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->CurrentStack->Depth + 1);
-+ break;
-+ case GL_CURRENT_MATRIX_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetFloatv");
-+ {
-+ const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[1];
-+ params[2] = matrix[2];
-+ params[3] = matrix[3];
-+ params[4] = matrix[4];
-+ params[5] = matrix[5];
-+ params[6] = matrix[6];
-+ params[7] = matrix[7];
-+ params[8] = matrix[8];
-+ params[9] = matrix[9];
-+ params[10] = matrix[10];
-+ params[11] = matrix[11];
-+ params[12] = matrix[12];
-+ params[13] = matrix[13];
-+ params[14] = matrix[14];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-+ CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetFloatv");
-+ {
-+ const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+ params[0] = matrix[0];
-+ params[1] = matrix[4];
-+ params[2] = matrix[8];
-+ params[3] = matrix[12];
-+ params[4] = matrix[1];
-+ params[5] = matrix[5];
-+ params[6] = matrix[9];
-+ params[7] = matrix[13];
-+ params[8] = matrix[2];
-+ params[9] = matrix[6];
-+ params[10] = matrix[10];
-+ params[11] = matrix[14];
-+ params[12] = matrix[3];
-+ params[13] = matrix[7];
-+ params[14] = matrix[11];
-+ params[15] = matrix[15];
-+ }
-+ break;
-+ case GL_MAX_VERTEX_ATTRIBS_ARB:
-+ CHECK_EXT1(ARB_vertex_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.VertexProgram.MaxAttribs);
-+ break;
-+ case GL_PROGRAM_ERROR_POSITION_ARB:
-+ CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Program.ErrorPos);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_ARB:
-+ CHECK_EXT1(ARB_fragment_program, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.Enabled);
-+ break;
-+ case GL_MAX_TEXTURE_COORDS_ARB:
-+ CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxTextureCoordUnits);
-+ break;
-+ case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxTextureImageUnits);
-+ break;
-+ case GL_DEPTH_BOUNDS_TEST_EXT:
-+ CHECK_EXT1(EXT_depth_bounds_test, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.BoundsTest);
-+ break;
-+ case GL_DEPTH_BOUNDS_EXT:
-+ CHECK_EXT1(EXT_depth_bounds_test, "GetFloatv");
-+ params[0] = ctx->Depth.BoundsMin;
-+ params[1] = ctx->Depth.BoundsMax;
-+ break;
-+ case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.CallbackEnabled);
-+ break;
-+ case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.CallbackEnabled);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->FragmentProgram.CurrentPosition);
-+ break;
-+ case GL_VERTEX_PROGRAM_POSITION_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->VertexProgram.CurrentPosition);
-+ break;
-+ case GL_MAX_DRAW_BUFFERS_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers);
-+ break;
-+ case GL_DRAW_BUFFER0_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+ break;
-+ case GL_DRAW_BUFFER1_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
-+ params[0] = ENUM_TO_FLOAT(buffer);
-+ }
-+ break;
-+ case GL_DRAW_BUFFER2_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
-+ params[0] = ENUM_TO_FLOAT(buffer);
-+ }
-+ break;
-+ case GL_DRAW_BUFFER3_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
-+ params[0] = ENUM_TO_FLOAT(buffer);
-+ }
-+ break;
-+ case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-+ CHECK_EXT1(OES_read_format, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.ColorReadType);
-+ break;
-+ case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-+ CHECK_EXT1(OES_read_format, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.ColorReadFormat);
-+ break;
-+ case GL_NUM_FRAGMENT_REGISTERS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(6);
-+ break;
-+ case GL_NUM_FRAGMENT_CONSTANTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(8);
-+ break;
-+ case GL_NUM_PASSES_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(2);
-+ break;
-+ case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(8);
-+ break;
-+ case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(16);
-+ break;
-+ case GL_COLOR_ALPHA_PAIRING_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = BOOLEAN_TO_FLOAT(GL_TRUE);
-+ break;
-+ case GL_NUM_LOOPBACK_COMPONENTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(3);
-+ break;
-+ case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(3);
-+ break;
-+ case GL_STENCIL_BACK_FUNC:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.Function[1]);
-+ break;
-+ case GL_STENCIL_BACK_VALUE_MASK:
-+ params[0] = (GLfloat)(ctx->Stencil.ValueMask[1]);
-+ break;
-+ case GL_STENCIL_BACK_REF:
-+ params[0] = (GLfloat)(ctx->Stencil.Ref[1]);
-+ break;
-+ case GL_STENCIL_BACK_FAIL:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[1]);
-+ break;
-+ case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[1]);
-+ break;
-+ case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-+ params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[1]);
-+ break;
-+ case GL_FRAMEBUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->DrawBuffer->Name);
-+ break;
-+ case GL_RENDERBUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0);
-+ break;
-+ case GL_MAX_COLOR_ATTACHMENTS_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxColorAttachments);
-+ break;
-+ case GL_MAX_RENDERBUFFER_SIZE_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+ params[0] = (GLfloat)(ctx->Const.MaxRenderbufferSize);
-+ break;
-+ case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
-+ CHECK_EXT1(ARB_fragment_shader, "GetFloatv");
-+ params[0] = (GLfloat)(MAX_FRAGMENT_UNIFORM_COMPONENTS);
-+ break;
-+ case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-+ CHECK_EXT1(ARB_fragment_shader, "GetFloatv");
-+ params[0] = ENUM_TO_FLOAT(ctx->Hint.FragmentShaderDerivative);
-+ break;
-+ case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+ params[0] = (GLfloat)(MAX_VERTEX_UNIFORM_COMPONENTS);
-+ break;
-+ case GL_MAX_VARYING_FLOATS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+ params[0] = (GLfloat)(MAX_VARYING_FLOATS);
-+ break;
-+ case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+ params[0] = (GLfloat)(MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-+ break;
-+ case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+ params[0] = (GLfloat)(MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-+ break;
-+ default:
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv(pname=0x%x)", pname);
-+ }
-+}
-+
-+void GLAPIENTRY
-+_mesa_GetIntegerv( GLenum pname, GLint *params )
-+{
-+ GET_CURRENT_CONTEXT(ctx);
-+ ASSERT_OUTSIDE_BEGIN_END(ctx);
-+
-+ if (!params)
-+ return;
-+
-+ if (ctx->NewState)
-+ _mesa_update_state(ctx);
-+
-+ if (ctx->Driver.GetIntegerv &&
-+ ctx->Driver.GetIntegerv(ctx, pname, params))
-+ return;
-+
-+ switch (pname) {
-+ case GL_ACCUM_RED_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.accumRedBits;
-+ break;
-+ case GL_ACCUM_GREEN_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.accumGreenBits;
-+ break;
-+ case GL_ACCUM_BLUE_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.accumBlueBits;
-+ break;
-+ case GL_ACCUM_ALPHA_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.accumAlphaBits;
-+ break;
-+ case GL_ACCUM_CLEAR_VALUE:
-+ params[0] = FLOAT_TO_INT(ctx->Accum.ClearColor[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Accum.ClearColor[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Accum.ClearColor[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Accum.ClearColor[3]);
-+ break;
-+ case GL_ALPHA_BIAS:
-+ params[0] = IROUND(ctx->Pixel.AlphaBias);
-+ break;
-+ case GL_ALPHA_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.alphaBits;
-+ break;
-+ case GL_ALPHA_SCALE:
-+ params[0] = IROUND(ctx->Pixel.AlphaScale);
-+ break;
-+ case GL_ALPHA_TEST:
-+ params[0] = BOOLEAN_TO_INT(ctx->Color.AlphaEnabled);
-+ break;
-+ case GL_ALPHA_TEST_FUNC:
-+ params[0] = ENUM_TO_INT(ctx->Color.AlphaFunc);
-+ break;
-+ case GL_ALPHA_TEST_REF:
-+ params[0] = FLOAT_TO_INT(ctx->Color.AlphaRef);
-+ break;
-+ case GL_ATTRIB_STACK_DEPTH:
-+ params[0] = ctx->AttribStackDepth;
-+ break;
-+ case GL_AUTO_NORMAL:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.AutoNormal);
-+ break;
-+ case GL_AUX_BUFFERS:
-+ params[0] = ctx->DrawBuffer->Visual.numAuxBuffers;
-+ break;
-+ case GL_BLEND:
-+ params[0] = BOOLEAN_TO_INT(ctx->Color.BlendEnabled);
-+ break;
-+ case GL_BLEND_DST:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendDstRGB);
-+ break;
-+ case GL_BLEND_SRC:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendSrcRGB);
-+ break;
-+ case GL_BLEND_SRC_RGB_EXT:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendSrcRGB);
-+ break;
-+ case GL_BLEND_DST_RGB_EXT:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendDstRGB);
-+ break;
-+ case GL_BLEND_SRC_ALPHA_EXT:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendSrcA);
-+ break;
-+ case GL_BLEND_DST_ALPHA_EXT:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendDstA);
-+ break;
-+ case GL_BLEND_EQUATION:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendEquationRGB );
-+ break;
-+ case GL_BLEND_EQUATION_ALPHA_EXT:
-+ params[0] = ENUM_TO_INT(ctx->Color.BlendEquationA );
-+ break;
-+ case GL_BLEND_COLOR_EXT:
-+ params[0] = FLOAT_TO_INT(ctx->Color.BlendColor[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Color.BlendColor[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Color.BlendColor[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Color.BlendColor[3]);
-+ break;
-+ case GL_BLUE_BIAS:
-+ params[0] = IROUND(ctx->Pixel.BlueBias);
-+ break;
-+ case GL_BLUE_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.blueBits;
-+ break;
-+ case GL_BLUE_SCALE:
-+ params[0] = IROUND(ctx->Pixel.BlueScale);
-+ break;
-+ case GL_CLIENT_ATTRIB_STACK_DEPTH:
-+ params[0] = ctx->ClientAttribStackDepth;
-+ break;
-+ case GL_CLIP_PLANE0:
-+ params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
-+ break;
-+ case GL_CLIP_PLANE1:
-+ params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
-+ break;
-+ case GL_CLIP_PLANE2:
-+ params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
-+ break;
-+ case GL_CLIP_PLANE3:
-+ params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
-+ break;
-+ case GL_CLIP_PLANE4:
-+ params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
-+ break;
-+ case GL_CLIP_PLANE5:
-+ params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
-+ break;
-+ case GL_COLOR_CLEAR_VALUE:
-+ params[0] = FLOAT_TO_INT(ctx->Color.ClearColor[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Color.ClearColor[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Color.ClearColor[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Color.ClearColor[3]);
-+ break;
-+ case GL_COLOR_MATERIAL:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.ColorMaterialEnabled);
-+ break;
-+ case GL_COLOR_MATERIAL_FACE:
-+ params[0] = ENUM_TO_INT(ctx->Light.ColorMaterialFace);
-+ break;
-+ case GL_COLOR_MATERIAL_PARAMETER:
-+ params[0] = ENUM_TO_INT(ctx->Light.ColorMaterialMode);
-+ break;
-+ case GL_COLOR_WRITEMASK:
-+ params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
-+ params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
-+ params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
-+ params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
-+ break;
-+ case GL_CULL_FACE:
-+ params[0] = BOOLEAN_TO_INT(ctx->Polygon.CullFlag);
-+ break;
-+ case GL_CULL_FACE_MODE:
-+ params[0] = ENUM_TO_INT(ctx->Polygon.CullFaceMode);
-+ break;
-+ case GL_CURRENT_COLOR:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
-+ params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
-+ params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
-+ params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
-+ }
-+ break;
-+ case GL_CURRENT_INDEX:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]);
-+ }
-+ break;
-+ case GL_CURRENT_NORMAL:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
-+ params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
-+ params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
-+ }
-+ break;
-+ case GL_CURRENT_RASTER_COLOR:
-+ params[0] = FLOAT_TO_INT(ctx->Current.RasterColor[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Current.RasterColor[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Current.RasterColor[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Current.RasterColor[3]);
-+ break;
-+ case GL_CURRENT_RASTER_DISTANCE:
-+ params[0] = IROUND(ctx->Current.RasterDistance);
-+ break;
-+ case GL_CURRENT_RASTER_INDEX:
-+ params[0] = IROUND(ctx->Current.RasterIndex);
-+ break;
-+ case GL_CURRENT_RASTER_POSITION:
-+ params[0] = IROUND(ctx->Current.RasterPos[0]);
-+ params[1] = IROUND(ctx->Current.RasterPos[1]);
-+ params[2] = IROUND(ctx->Current.RasterPos[2]);
-+ params[3] = IROUND(ctx->Current.RasterPos[3]);
-+ break;
-+ case GL_CURRENT_RASTER_SECONDARY_COLOR:
-+ params[0] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[3]);
-+ break;
-+ case GL_CURRENT_RASTER_TEXTURE_COORDS:
-+ {
-+ const GLuint texUnit = ctx->Texture.CurrentUnit;
-+ params[0] = IROUND(ctx->Current.RasterTexCoords[texUnit][0]);
-+ params[1] = IROUND(ctx->Current.RasterTexCoords[texUnit][1]);
-+ params[2] = IROUND(ctx->Current.RasterTexCoords[texUnit][2]);
-+ params[3] = IROUND(ctx->Current.RasterTexCoords[texUnit][3]);
-+ }
-+ break;
-+ case GL_CURRENT_RASTER_POSITION_VALID:
-+ params[0] = BOOLEAN_TO_INT(ctx->Current.RasterPosValid);
-+ break;
-+ case GL_CURRENT_TEXTURE_COORDS:
-+ {
-+ const GLuint texUnit = ctx->Texture.CurrentUnit;
-+ params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
-+ params[1] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
-+ params[2] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
-+ params[3] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
-+ }
-+ break;
-+ case GL_DEPTH_BIAS:
-+ params[0] = IROUND(ctx->Pixel.DepthBias);
-+ break;
-+ case GL_DEPTH_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.depthBits;
-+ break;
-+ case GL_DEPTH_CLEAR_VALUE:
-+ params[0] = IROUND(ctx->Depth.Clear);
-+ break;
-+ case GL_DEPTH_FUNC:
-+ params[0] = ENUM_TO_INT(ctx->Depth.Func);
-+ break;
-+ case GL_DEPTH_RANGE:
-+ params[0] = FLOAT_TO_INT(ctx->Viewport.Near);
-+ params[1] = FLOAT_TO_INT(ctx->Viewport.Far);
-+ break;
-+ case GL_DEPTH_SCALE:
-+ params[0] = IROUND(ctx->Pixel.DepthScale);
-+ break;
-+ case GL_DEPTH_TEST:
-+ params[0] = BOOLEAN_TO_INT(ctx->Depth.Test);
-+ break;
-+ case GL_DEPTH_WRITEMASK:
-+ params[0] = BOOLEAN_TO_INT(ctx->Depth.Mask);
-+ break;
-+ case GL_DITHER:
-+ params[0] = BOOLEAN_TO_INT(ctx->Color.DitherFlag);
-+ break;
-+ case GL_DOUBLEBUFFER:
-+ params[0] = BOOLEAN_TO_INT(ctx->DrawBuffer->Visual.doubleBufferMode);
-+ break;
-+ case GL_DRAW_BUFFER:
-+ params[0] = ENUM_TO_INT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+ break;
-+ case GL_EDGE_FLAG:
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = BOOLEAN_TO_INT(ctx->Current.EdgeFlag);
-+ }
-+ break;
-+ case GL_FEEDBACK_BUFFER_SIZE:
-+ params[0] = ctx->Feedback.BufferSize;
-+ break;
-+ case GL_FEEDBACK_BUFFER_TYPE:
-+ params[0] = ENUM_TO_INT(ctx->Feedback.Type);
-+ break;
-+ case GL_FOG:
-+ params[0] = BOOLEAN_TO_INT(ctx->Fog.Enabled);
-+ break;
-+ case GL_FOG_COLOR:
-+ params[0] = FLOAT_TO_INT(ctx->Fog.Color[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Fog.Color[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Fog.Color[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Fog.Color[3]);
-+ break;
-+ case GL_FOG_DENSITY:
-+ params[0] = IROUND(ctx->Fog.Density);
-+ break;
-+ case GL_FOG_END:
-+ params[0] = IROUND(ctx->Fog.End);
-+ break;
-+ case GL_FOG_HINT:
-+ params[0] = ENUM_TO_INT(ctx->Hint.Fog);
-+ break;
-+ case GL_FOG_INDEX:
-+ params[0] = IROUND(ctx->Fog.Index);
-+ break;
-+ case GL_FOG_MODE:
-+ params[0] = ENUM_TO_INT(ctx->Fog.Mode);
-+ break;
-+ case GL_FOG_START:
-+ params[0] = IROUND(ctx->Fog.Start);
-+ break;
-+ case GL_FRONT_FACE:
-+ params[0] = ENUM_TO_INT(ctx->Polygon.FrontFace);
-+ break;
-+ case GL_GREEN_BIAS:
-+ params[0] = IROUND(ctx->Pixel.GreenBias);
-+ break;
-+ case GL_GREEN_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.greenBits;
-+ break;
-+ case GL_GREEN_SCALE:
-+ params[0] = IROUND(ctx->Pixel.GreenScale);
-+ break;
-+ case GL_INDEX_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.indexBits;
-+ break;
-+ case GL_INDEX_CLEAR_VALUE:
-+ params[0] = ctx->Color.ClearIndex;
-+ break;
-+ case GL_INDEX_MODE:
-+ params[0] = BOOLEAN_TO_INT(!ctx->DrawBuffer->Visual.rgbMode);
-+ break;
-+ case GL_INDEX_OFFSET:
-+ params[0] = ctx->Pixel.IndexOffset;
-+ break;
-+ case GL_INDEX_SHIFT:
-+ params[0] = ctx->Pixel.IndexShift;
-+ break;
-+ case GL_INDEX_WRITEMASK:
-+ params[0] = ctx->Color.IndexMask;
-+ break;
-+ case GL_LIGHT0:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[0].Enabled);
-+ break;
-+ case GL_LIGHT1:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[1].Enabled);
-+ break;
-+ case GL_LIGHT2:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[2].Enabled);
-+ break;
-+ case GL_LIGHT3:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[3].Enabled);
-+ break;
-+ case GL_LIGHT4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[4].Enabled);
-+ break;
-+ case GL_LIGHT5:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[5].Enabled);
-+ break;
-+ case GL_LIGHT6:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[6].Enabled);
-+ break;
-+ case GL_LIGHT7:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Light[7].Enabled);
-+ break;
-+ case GL_LIGHTING:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Enabled);
-+ break;
-+ case GL_LIGHT_MODEL_AMBIENT:
-+ params[0] = FLOAT_TO_INT(ctx->Light.Model.Ambient[0]);
-+ params[1] = FLOAT_TO_INT(ctx->Light.Model.Ambient[1]);
-+ params[2] = FLOAT_TO_INT(ctx->Light.Model.Ambient[2]);
-+ params[3] = FLOAT_TO_INT(ctx->Light.Model.Ambient[3]);
-+ break;
-+ case GL_LIGHT_MODEL_COLOR_CONTROL:
-+ params[0] = ENUM_TO_INT(ctx->Light.Model.ColorControl);
-+ break;
-+ case GL_LIGHT_MODEL_LOCAL_VIEWER:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Model.LocalViewer);
-+ break;
-+ case GL_LIGHT_MODEL_TWO_SIDE:
-+ params[0] = BOOLEAN_TO_INT(ctx->Light.Model.TwoSide);
-+ break;
-+ case GL_LINE_SMOOTH:
-+ params[0] = BOOLEAN_TO_INT(ctx->Line.SmoothFlag);
-+ break;
-+ case GL_LINE_SMOOTH_HINT:
-+ params[0] = ENUM_TO_INT(ctx->Hint.LineSmooth);
-+ break;
-+ case GL_LINE_STIPPLE:
-+ params[0] = BOOLEAN_TO_INT(ctx->Line.StippleFlag);
-+ break;
-+ case GL_LINE_STIPPLE_PATTERN:
-+ params[0] = ctx->Line.StipplePattern;
-+ break;
-+ case GL_LINE_STIPPLE_REPEAT:
-+ params[0] = ctx->Line.StippleFactor;
-+ break;
-+ case GL_LINE_WIDTH:
-+ params[0] = IROUND(ctx->Line.Width);
-+ break;
-+ case GL_LINE_WIDTH_GRANULARITY:
-+ params[0] = IROUND(ctx->Const.LineWidthGranularity);
-+ break;
-+ case GL_LINE_WIDTH_RANGE:
-+ params[0] = IROUND(ctx->Const.MinLineWidthAA);
-+ params[1] = IROUND(ctx->Const.MaxLineWidthAA);
-+ break;
-+ case GL_ALIASED_LINE_WIDTH_RANGE:
-+ params[0] = IROUND(ctx->Const.MinLineWidth);
-+ params[1] = IROUND(ctx->Const.MaxLineWidth);
-+ break;
-+ case GL_LIST_BASE:
-+ params[0] = ctx->List.ListBase;
-+ break;
-+ case GL_LIST_INDEX:
-+ params[0] = ctx->ListState.CurrentListNum;
-+ break;
-+ case GL_LIST_MODE:
-+ {
-+ GLenum mode;
-+ if (!ctx->CompileFlag)
-+ mode = 0;
-+ else if (ctx->ExecuteFlag)
-+ mode = GL_COMPILE_AND_EXECUTE;
-+ else
-+ mode = GL_COMPILE;
-+ params[0] = ENUM_TO_INT(mode);
-+ }
-+ break;
-+ case GL_INDEX_LOGIC_OP:
-+ params[0] = BOOLEAN_TO_INT(ctx->Color.IndexLogicOpEnabled);
-+ break;
-+ case GL_COLOR_LOGIC_OP:
-+ params[0] = BOOLEAN_TO_INT(ctx->Color.ColorLogicOpEnabled);
-+ break;
-+ case GL_LOGIC_OP_MODE:
-+ params[0] = ENUM_TO_INT(ctx->Color.LogicOp);
-+ break;
-+ case GL_MAP1_COLOR_4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Color4);
-+ break;
-+ case GL_MAP1_GRID_DOMAIN:
-+ params[0] = IROUND(ctx->Eval.MapGrid1u1);
-+ params[1] = IROUND(ctx->Eval.MapGrid1u2);
-+ break;
-+ case GL_MAP1_GRID_SEGMENTS:
-+ params[0] = ctx->Eval.MapGrid1un;
-+ break;
-+ case GL_MAP1_INDEX:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Index);
-+ break;
-+ case GL_MAP1_NORMAL:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Normal);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_1:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord1);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_2:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord2);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_3:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord3);
-+ break;
-+ case GL_MAP1_TEXTURE_COORD_4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord4);
-+ break;
-+ case GL_MAP1_VERTEX_3:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Vertex3);
-+ break;
-+ case GL_MAP1_VERTEX_4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Vertex4);
-+ break;
-+ case GL_MAP2_COLOR_4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Color4);
-+ break;
-+ case GL_MAP2_GRID_DOMAIN:
-+ params[0] = IROUND(ctx->Eval.MapGrid2u1);
-+ params[1] = IROUND(ctx->Eval.MapGrid2u2);
-+ params[2] = IROUND(ctx->Eval.MapGrid2v1);
-+ params[3] = IROUND(ctx->Eval.MapGrid2v2);
-+ break;
-+ case GL_MAP2_GRID_SEGMENTS:
-+ params[0] = ctx->Eval.MapGrid2un;
-+ params[1] = ctx->Eval.MapGrid2vn;
-+ break;
-+ case GL_MAP2_INDEX:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Index);
-+ break;
-+ case GL_MAP2_NORMAL:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Normal);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_1:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord1);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_2:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord2);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_3:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord3);
-+ break;
-+ case GL_MAP2_TEXTURE_COORD_4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord4);
-+ break;
-+ case GL_MAP2_VERTEX_3:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Vertex3);
-+ break;
-+ case GL_MAP2_VERTEX_4:
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Vertex4);
-+ break;
-+ case GL_MAP_COLOR:
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.MapColorFlag);
-+ break;
-+ case GL_MAP_STENCIL:
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.MapStencilFlag);
-+ break;
-+ case GL_MATRIX_MODE:
-+ params[0] = ENUM_TO_INT(ctx->Transform.MatrixMode);
-+ break;
-+ case GL_MAX_ATTRIB_STACK_DEPTH:
-+ params[0] = MAX_ATTRIB_STACK_DEPTH;
-+ break;
-+ case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-+ params[0] = MAX_CLIENT_ATTRIB_STACK_DEPTH;
-+ break;
-+ case GL_MAX_CLIP_PLANES:
-+ params[0] = ctx->Const.MaxClipPlanes;
-+ break;
-+ case GL_MAX_ELEMENTS_VERTICES:
-+ params[0] = ctx->Const.MaxArrayLockSize;
-+ break;
-+ case GL_MAX_ELEMENTS_INDICES:
-+ params[0] = ctx->Const.MaxArrayLockSize;
-+ break;
-+ case GL_MAX_EVAL_ORDER:
-+ params[0] = MAX_EVAL_ORDER;
-+ break;
-+ case GL_MAX_LIGHTS:
-+ params[0] = ctx->Const.MaxLights;
-+ break;
-+ case GL_MAX_LIST_NESTING:
-+ params[0] = MAX_LIST_NESTING;
-+ break;
-+ case GL_MAX_MODELVIEW_STACK_DEPTH:
-+ params[0] = MAX_MODELVIEW_STACK_DEPTH;
-+ break;
-+ case GL_MAX_NAME_STACK_DEPTH:
-+ params[0] = MAX_NAME_STACK_DEPTH;
-+ break;
-+ case GL_MAX_PIXEL_MAP_TABLE:
-+ params[0] = MAX_PIXEL_MAP_TABLE;
-+ break;
-+ case GL_MAX_PROJECTION_STACK_DEPTH:
-+ params[0] = MAX_PROJECTION_STACK_DEPTH;
-+ break;
-+ case GL_MAX_TEXTURE_SIZE:
-+ params[0] = 1 << (ctx->Const.MaxTextureLevels - 1);
-+ break;
-+ case GL_MAX_3D_TEXTURE_SIZE:
-+ params[0] = 1 << (ctx->Const.Max3DTextureLevels - 1);
-+ break;
-+ case GL_MAX_TEXTURE_STACK_DEPTH:
-+ params[0] = MAX_TEXTURE_STACK_DEPTH;
-+ break;
-+ case GL_MAX_VIEWPORT_DIMS:
-+ params[0] = ctx->Const.MaxViewportWidth;
-+ params[1] = ctx->Const.MaxViewportHeight;
-+ break;
-+ case GL_MODELVIEW_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[1]);
-+ params[2] = IROUND(matrix[2]);
-+ params[3] = IROUND(matrix[3]);
-+ params[4] = IROUND(matrix[4]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[6]);
-+ params[7] = IROUND(matrix[7]);
-+ params[8] = IROUND(matrix[8]);
-+ params[9] = IROUND(matrix[9]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[11]);
-+ params[12] = IROUND(matrix[12]);
-+ params[13] = IROUND(matrix[13]);
-+ params[14] = IROUND(matrix[14]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_MODELVIEW_STACK_DEPTH:
-+ params[0] = ctx->ModelviewMatrixStack.Depth + 1;
-+ break;
-+ case GL_NAME_STACK_DEPTH:
-+ params[0] = ctx->Select.NameStackDepth;
-+ break;
-+ case GL_NORMALIZE:
-+ params[0] = BOOLEAN_TO_INT(ctx->Transform.Normalize);
-+ break;
-+ case GL_PACK_ALIGNMENT:
-+ params[0] = ctx->Pack.Alignment;
-+ break;
-+ case GL_PACK_LSB_FIRST:
-+ params[0] = BOOLEAN_TO_INT(ctx->Pack.LsbFirst);
-+ break;
-+ case GL_PACK_ROW_LENGTH:
-+ params[0] = ctx->Pack.RowLength;
-+ break;
-+ case GL_PACK_SKIP_PIXELS:
-+ params[0] = ctx->Pack.SkipPixels;
-+ break;
-+ case GL_PACK_SKIP_ROWS:
-+ params[0] = ctx->Pack.SkipRows;
-+ break;
-+ case GL_PACK_SWAP_BYTES:
-+ params[0] = BOOLEAN_TO_INT(ctx->Pack.SwapBytes);
-+ break;
-+ case GL_PACK_SKIP_IMAGES_EXT:
-+ params[0] = ctx->Pack.SkipImages;
-+ break;
-+ case GL_PACK_IMAGE_HEIGHT_EXT:
-+ params[0] = ctx->Pack.ImageHeight;
-+ break;
-+ case GL_PACK_INVERT_MESA:
-+ params[0] = BOOLEAN_TO_INT(ctx->Pack.Invert);
-+ break;
-+ case GL_PERSPECTIVE_CORRECTION_HINT:
-+ params[0] = ENUM_TO_INT(ctx->Hint.PerspectiveCorrection);
-+ break;
-+ case GL_PIXEL_MAP_A_TO_A_SIZE:
-+ params[0] = ctx->Pixel.MapAtoAsize;
-+ break;
-+ case GL_PIXEL_MAP_B_TO_B_SIZE:
-+ params[0] = ctx->Pixel.MapBtoBsize;
-+ break;
-+ case GL_PIXEL_MAP_G_TO_G_SIZE:
-+ params[0] = ctx->Pixel.MapGtoGsize;
-+ break;
-+ case GL_PIXEL_MAP_I_TO_A_SIZE:
-+ params[0] = ctx->Pixel.MapItoAsize;
-+ break;
-+ case GL_PIXEL_MAP_I_TO_B_SIZE:
-+ params[0] = ctx->Pixel.MapItoBsize;
-+ break;
-+ case GL_PIXEL_MAP_I_TO_G_SIZE:
-+ params[0] = ctx->Pixel.MapItoGsize;
-+ break;
-+ case GL_PIXEL_MAP_I_TO_I_SIZE:
-+ params[0] = ctx->Pixel.MapItoIsize;
-+ break;
-+ case GL_PIXEL_MAP_I_TO_R_SIZE:
-+ params[0] = ctx->Pixel.MapItoRsize;
-+ break;
-+ case GL_PIXEL_MAP_R_TO_R_SIZE:
-+ params[0] = ctx->Pixel.MapRtoRsize;
-+ break;
-+ case GL_PIXEL_MAP_S_TO_S_SIZE:
-+ params[0] = ctx->Pixel.MapStoSsize;
-+ break;
-+ case GL_POINT_SIZE:
-+ params[0] = IROUND(ctx->Point.Size);
-+ break;
-+ case GL_POINT_SIZE_GRANULARITY:
-+ params[0] = IROUND(ctx->Const.PointSizeGranularity);
-+ break;
-+ case GL_POINT_SIZE_RANGE:
-+ params[0] = IROUND(ctx->Const.MinPointSizeAA);
-+ params[1] = IROUND(ctx->Const.MaxPointSizeAA);
-+ break;
-+ case GL_ALIASED_POINT_SIZE_RANGE:
-+ params[0] = IROUND(ctx->Const.MinPointSize);
-+ params[1] = IROUND(ctx->Const.MaxPointSize);
-+ break;
-+ case GL_POINT_SMOOTH:
-+ params[0] = BOOLEAN_TO_INT(ctx->Point.SmoothFlag);
-+ break;
-+ case GL_POINT_SMOOTH_HINT:
-+ params[0] = ENUM_TO_INT(ctx->Hint.PointSmooth);
-+ break;
-+ case GL_POINT_SIZE_MIN_EXT:
-+ params[0] = IROUND(ctx->Point.MinSize);
-+ break;
-+ case GL_POINT_SIZE_MAX_EXT:
-+ params[0] = IROUND(ctx->Point.MaxSize);
-+ break;
-+ case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
-+ params[0] = IROUND(ctx->Point.Threshold);
-+ break;
-+ case GL_DISTANCE_ATTENUATION_EXT:
-+ params[0] = IROUND(ctx->Point.Params[0]);
-+ params[1] = IROUND(ctx->Point.Params[1]);
-+ params[2] = IROUND(ctx->Point.Params[2]);
-+ break;
-+ case GL_POLYGON_MODE:
-+ params[0] = ENUM_TO_INT(ctx->Polygon.FrontMode);
-+ params[1] = ENUM_TO_INT(ctx->Polygon.BackMode);
-+ break;
-+ case GL_POLYGON_OFFSET_BIAS_EXT:
-+ params[0] = IROUND(ctx->Polygon.OffsetUnits);
-+ break;
-+ case GL_POLYGON_OFFSET_FACTOR:
-+ params[0] = IROUND(ctx->Polygon.OffsetFactor );
-+ break;
-+ case GL_POLYGON_OFFSET_UNITS:
-+ params[0] = IROUND(ctx->Polygon.OffsetUnits );
-+ break;
-+ case GL_POLYGON_SMOOTH:
-+ params[0] = BOOLEAN_TO_INT(ctx->Polygon.SmoothFlag);
-+ break;
-+ case GL_POLYGON_SMOOTH_HINT:
-+ params[0] = ENUM_TO_INT(ctx->Hint.PolygonSmooth);
-+ break;
-+ case GL_POLYGON_STIPPLE:
-+ params[0] = BOOLEAN_TO_INT(ctx->Polygon.StippleFlag);
-+ break;
-+ case GL_PROJECTION_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[1]);
-+ params[2] = IROUND(matrix[2]);
-+ params[3] = IROUND(matrix[3]);
-+ params[4] = IROUND(matrix[4]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[6]);
-+ params[7] = IROUND(matrix[7]);
-+ params[8] = IROUND(matrix[8]);
-+ params[9] = IROUND(matrix[9]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[11]);
-+ params[12] = IROUND(matrix[12]);
-+ params[13] = IROUND(matrix[13]);
-+ params[14] = IROUND(matrix[14]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_PROJECTION_STACK_DEPTH:
-+ params[0] = ctx->ProjectionMatrixStack.Depth + 1;
-+ break;
-+ case GL_READ_BUFFER:
-+ params[0] = ENUM_TO_INT(ctx->ReadBuffer->ColorReadBuffer);
-+ break;
-+ case GL_RED_BIAS:
-+ params[0] = IROUND(ctx->Pixel.RedBias);
-+ break;
-+ case GL_RED_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.redBits ;
-+ break;
-+ case GL_RED_SCALE:
-+ params[0] = IROUND(ctx->Pixel.RedScale);
-+ break;
-+ case GL_RENDER_MODE:
-+ params[0] = ENUM_TO_INT(ctx->RenderMode);
-+ break;
-+ case GL_RESCALE_NORMAL:
-+ params[0] = BOOLEAN_TO_INT(ctx->Transform.RescaleNormals);
-+ break;
-+ case GL_RGBA_MODE:
-+ params[0] = BOOLEAN_TO_INT(ctx->DrawBuffer->Visual.rgbMode);
-+ break;
-+ case GL_SCISSOR_BOX:
-+ params[0] = ctx->Scissor.X;
-+ params[1] = ctx->Scissor.Y;
-+ params[2] = ctx->Scissor.Width;
-+ params[3] = ctx->Scissor.Height;
-+ break;
-+ case GL_SCISSOR_TEST:
-+ params[0] = BOOLEAN_TO_INT(ctx->Scissor.Enabled);
-+ break;
-+ case GL_SELECTION_BUFFER_SIZE:
-+ params[0] = ctx->Select.BufferSize;
-+ break;
-+ case GL_SHADE_MODEL:
-+ params[0] = ENUM_TO_INT(ctx->Light.ShadeModel);
-+ break;
-+ case GL_SHARED_TEXTURE_PALETTE_EXT:
-+ params[0] = BOOLEAN_TO_INT(ctx->Texture.SharedPalette);
-+ break;
-+ case GL_STENCIL_BITS:
-+ params[0] = ctx->DrawBuffer->Visual.stencilBits;
-+ break;
-+ case GL_STENCIL_CLEAR_VALUE:
-+ params[0] = ctx->Stencil.Clear;
-+ break;
-+ case GL_STENCIL_FAIL:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_FUNC:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_PASS_DEPTH_FAIL:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_PASS_DEPTH_PASS:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
-+ break;
-+ case GL_STENCIL_REF:
-+ params[0] = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
-+ break;
-+ case GL_STENCIL_TEST:
-+ params[0] = BOOLEAN_TO_INT(ctx->Stencil.Enabled);
-+ break;
-+ case GL_STENCIL_VALUE_MASK:
-+ params[0] = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
-+ break;
-+ case GL_STENCIL_WRITEMASK:
-+ params[0] = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
-+ break;
-+ case GL_STEREO:
-+ params[0] = BOOLEAN_TO_INT(ctx->DrawBuffer->Visual.stereoMode);
-+ break;
-+ case GL_SUBPIXEL_BITS:
-+ params[0] = ctx->Const.SubPixelBits;
-+ break;
-+ case GL_TEXTURE_1D:
-+ params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_1D));
-+ break;
-+ case GL_TEXTURE_2D:
-+ params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_2D));
-+ break;
-+ case GL_TEXTURE_3D:
-+ params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_3D));
-+ break;
-+ case GL_TEXTURE_BINDING_1D:
-+ params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name;
-+ break;
-+ case GL_TEXTURE_BINDING_2D:
-+ params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name;
-+ break;
-+ case GL_TEXTURE_BINDING_3D:
-+ params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name;
-+ break;
-+ case GL_TEXTURE_ENV_COLOR:
-+ {
-+ const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
-+ params[0] = FLOAT_TO_INT(color[0]);
-+ params[1] = FLOAT_TO_INT(color[1]);
-+ params[2] = FLOAT_TO_INT(color[2]);
-+ params[3] = FLOAT_TO_INT(color[3]);
-+ }
-+ break;
-+ case GL_TEXTURE_ENV_MODE:
-+ params[0] = ENUM_TO_INT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
-+ break;
-+ case GL_TEXTURE_GEN_S:
-+ params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_GEN_T:
-+ params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_GEN_R:
-+ params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_GEN_Q:
-+ params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
-+ break;
-+ case GL_TEXTURE_MATRIX:
-+ {
-+ const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[1]);
-+ params[2] = IROUND(matrix[2]);
-+ params[3] = IROUND(matrix[3]);
-+ params[4] = IROUND(matrix[4]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[6]);
-+ params[7] = IROUND(matrix[7]);
-+ params[8] = IROUND(matrix[8]);
-+ params[9] = IROUND(matrix[9]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[11]);
-+ params[12] = IROUND(matrix[12]);
-+ params[13] = IROUND(matrix[13]);
-+ params[14] = IROUND(matrix[14]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_TEXTURE_STACK_DEPTH:
-+ params[0] = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1;
-+ break;
-+ case GL_UNPACK_ALIGNMENT:
-+ params[0] = ctx->Unpack.Alignment;
-+ break;
-+ case GL_UNPACK_LSB_FIRST:
-+ params[0] = BOOLEAN_TO_INT(ctx->Unpack.LsbFirst);
-+ break;
-+ case GL_UNPACK_ROW_LENGTH:
-+ params[0] = ctx->Unpack.RowLength;
-+ break;
-+ case GL_UNPACK_SKIP_PIXELS:
-+ params[0] = ctx->Unpack.SkipPixels;
-+ break;
-+ case GL_UNPACK_SKIP_ROWS:
-+ params[0] = ctx->Unpack.SkipRows;
-+ break;
-+ case GL_UNPACK_SWAP_BYTES:
-+ params[0] = BOOLEAN_TO_INT(ctx->Unpack.SwapBytes);
-+ break;
-+ case GL_UNPACK_SKIP_IMAGES_EXT:
-+ params[0] = ctx->Unpack.SkipImages;
-+ break;
-+ case GL_UNPACK_IMAGE_HEIGHT_EXT:
-+ params[0] = ctx->Unpack.ImageHeight;
-+ break;
-+ case GL_UNPACK_CLIENT_STORAGE_APPLE:
-+ params[0] = BOOLEAN_TO_INT(ctx->Unpack.ClientStorage);
-+ break;
-+ case GL_VIEWPORT:
-+ params[0] = ctx->Viewport.X;
-+ params[1] = ctx->Viewport.Y;
-+ params[2] = ctx->Viewport.Width;
-+ params[3] = ctx->Viewport.Height;
-+ break;
-+ case GL_ZOOM_X:
-+ params[0] = IROUND(ctx->Pixel.ZoomX);
-+ break;
-+ case GL_ZOOM_Y:
-+ params[0] = IROUND(ctx->Pixel.ZoomY);
-+ break;
-+ case GL_VERTEX_ARRAY:
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->Vertex.Enabled);
-+ break;
-+ case GL_VERTEX_ARRAY_SIZE:
-+ params[0] = ctx->Array.ArrayObj->Vertex.Size;
-+ break;
-+ case GL_VERTEX_ARRAY_TYPE:
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Vertex.Type);
-+ break;
-+ case GL_VERTEX_ARRAY_STRIDE:
-+ params[0] = ctx->Array.ArrayObj->Vertex.Stride;
-+ break;
-+ case GL_VERTEX_ARRAY_COUNT_EXT:
-+ params[0] = 0;
-+ break;
-+ case GL_NORMAL_ARRAY:
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Normal.Enabled);
-+ break;
-+ case GL_NORMAL_ARRAY_TYPE:
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Normal.Type);
-+ break;
-+ case GL_NORMAL_ARRAY_STRIDE:
-+ params[0] = ctx->Array.ArrayObj->Normal.Stride;
-+ break;
-+ case GL_NORMAL_ARRAY_COUNT_EXT:
-+ params[0] = 0;
-+ break;
-+ case GL_COLOR_ARRAY:
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->Color.Enabled);
-+ break;
-+ case GL_COLOR_ARRAY_SIZE:
-+ params[0] = ctx->Array.ArrayObj->Color.Size;
-+ break;
-+ case GL_COLOR_ARRAY_TYPE:
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Color.Type);
-+ break;
-+ case GL_COLOR_ARRAY_STRIDE:
-+ params[0] = ctx->Array.ArrayObj->Color.Stride;
-+ break;
-+ case GL_COLOR_ARRAY_COUNT_EXT:
-+ params[0] = 0;
-+ break;
-+ case GL_INDEX_ARRAY:
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->Index.Enabled);
-+ break;
-+ case GL_INDEX_ARRAY_TYPE:
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Index.Type);
-+ break;
-+ case GL_INDEX_ARRAY_STRIDE:
-+ params[0] = ctx->Array.ArrayObj->Index.Stride;
-+ break;
-+ case GL_INDEX_ARRAY_COUNT_EXT:
-+ params[0] = 0;
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY:
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_SIZE:
-+ params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size;
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_TYPE:
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
-+ params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride;
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
-+ params[0] = 0;
-+ break;
-+ case GL_EDGE_FLAG_ARRAY:
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->EdgeFlag.Enabled);
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_STRIDE:
-+ params[0] = ctx->Array.ArrayObj->EdgeFlag.Stride;
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
-+ params[0] = 0;
-+ break;
-+ case GL_MAX_TEXTURE_UNITS_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetIntegerv");
-+ params[0] = ctx->Const.MaxTextureUnits;
-+ break;
-+ case GL_ACTIVE_TEXTURE_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetIntegerv");
-+ params[0] = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
-+ break;
-+ case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-+ CHECK_EXT1(ARB_multitexture, "GetIntegerv");
-+ params[0] = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
-+ break;
-+ case GL_TEXTURE_CUBE_MAP_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
-+ break;
-+ case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-+ params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name;
-+ break;
-+ case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-+ CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-+ params[0] = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-+ break;
-+ case GL_TEXTURE_COMPRESSION_HINT_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
-+ params[0] = ctx->Hint.TextureCompression;
-+ break;
-+ case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
-+ params[0] = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
-+ break;
-+ case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-+ CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
-+ {
-+ GLint formats[100];
-+ GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
-+ ASSERT(n <= 100);
-+ for (i = 0; i < n; i++)
-+ params[i] = ENUM_TO_INT(formats[i]);
-+ }
-+ break;
-+ case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-+ CHECK_EXT1(EXT_compiled_vertex_array, "GetIntegerv");
-+ params[0] = ctx->Array.LockFirst;
-+ break;
-+ case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-+ CHECK_EXT1(EXT_compiled_vertex_array, "GetIntegerv");
-+ params[0] = ctx->Array.LockCount;
-+ break;
-+ case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[4]);
-+ params[2] = IROUND(matrix[8]);
-+ params[3] = IROUND(matrix[12]);
-+ params[4] = IROUND(matrix[1]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[9]);
-+ params[7] = IROUND(matrix[13]);
-+ params[8] = IROUND(matrix[2]);
-+ params[9] = IROUND(matrix[6]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[14]);
-+ params[12] = IROUND(matrix[3]);
-+ params[13] = IROUND(matrix[7]);
-+ params[14] = IROUND(matrix[11]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[4]);
-+ params[2] = IROUND(matrix[8]);
-+ params[3] = IROUND(matrix[12]);
-+ params[4] = IROUND(matrix[1]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[9]);
-+ params[7] = IROUND(matrix[13]);
-+ params[8] = IROUND(matrix[2]);
-+ params[9] = IROUND(matrix[6]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[14]);
-+ params[12] = IROUND(matrix[3]);
-+ params[13] = IROUND(matrix[7]);
-+ params[14] = IROUND(matrix[11]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[4]);
-+ params[2] = IROUND(matrix[8]);
-+ params[3] = IROUND(matrix[12]);
-+ params[4] = IROUND(matrix[1]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[9]);
-+ params[7] = IROUND(matrix[13]);
-+ params[8] = IROUND(matrix[2]);
-+ params[9] = IROUND(matrix[6]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[14]);
-+ params[12] = IROUND(matrix[3]);
-+ params[13] = IROUND(matrix[7]);
-+ params[14] = IROUND(matrix[11]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-+ {
-+ const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[4]);
-+ params[2] = IROUND(matrix[8]);
-+ params[3] = IROUND(matrix[12]);
-+ params[4] = IROUND(matrix[1]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[9]);
-+ params[7] = IROUND(matrix[13]);
-+ params[8] = IROUND(matrix[2]);
-+ params[9] = IROUND(matrix[6]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[14]);
-+ params[12] = IROUND(matrix[3]);
-+ params[13] = IROUND(matrix[7]);
-+ params[14] = IROUND(matrix[11]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_COLOR_MATRIX_SGI:
-+ {
-+ const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[1]);
-+ params[2] = IROUND(matrix[2]);
-+ params[3] = IROUND(matrix[3]);
-+ params[4] = IROUND(matrix[4]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[6]);
-+ params[7] = IROUND(matrix[7]);
-+ params[8] = IROUND(matrix[8]);
-+ params[9] = IROUND(matrix[9]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[11]);
-+ params[12] = IROUND(matrix[12]);
-+ params[13] = IROUND(matrix[13]);
-+ params[14] = IROUND(matrix[14]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-+ params[0] = ctx->ColorMatrixStack.Depth + 1;
-+ break;
-+ case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
-+ params[0] = MAX_COLOR_STACK_DEPTH;
-+ break;
-+ case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[0]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[1]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[2]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[3]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[0]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[1]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[2]);
-+ break;
-+ case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
-+ params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[3]);
-+ break;
-+ case GL_CONVOLUTION_1D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.Convolution1DEnabled);
-+ break;
-+ case GL_CONVOLUTION_2D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.Convolution2DEnabled);
-+ break;
-+ case GL_SEPARABLE_2D_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.Separable2DEnabled);
-+ break;
-+ case GL_POST_CONVOLUTION_RED_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionScale[0]);
-+ break;
-+ case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionScale[1]);
-+ break;
-+ case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionScale[2]);
-+ break;
-+ case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionScale[3]);
-+ break;
-+ case GL_POST_CONVOLUTION_RED_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionBias[0]);
-+ break;
-+ case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionBias[1]);
-+ break;
-+ case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionBias[2]);
-+ break;
-+ case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
-+ CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+ params[0] = IROUND(ctx->Pixel.PostConvolutionBias[3]);
-+ break;
-+ case GL_HISTOGRAM:
-+ CHECK_EXT1(EXT_histogram, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.HistogramEnabled);
-+ break;
-+ case GL_MINMAX:
-+ CHECK_EXT1(EXT_histogram, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.MinMaxEnabled);
-+ break;
-+ case GL_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.ColorTableEnabled);
-+ break;
-+ case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.PostConvolutionColorTableEnabled);
-+ break;
-+ case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_color_table, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Pixel.PostColorMatrixColorTableEnabled);
-+ break;
-+ case GL_TEXTURE_COLOR_TABLE_SGI:
-+ CHECK_EXT1(SGI_texture_color_table, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
-+ break;
-+ case GL_COLOR_SUM_EXT:
-+ CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Fog.ColorSumEnabled);
-+ break;
-+ case GL_CURRENT_SECONDARY_COLOR_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
-+ params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
-+ params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
-+ params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
-+ }
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->SecondaryColor.Enabled);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->SecondaryColor.Type);
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->SecondaryColor.Stride;
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
-+ CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->SecondaryColor.Size;
-+ break;
-+ case GL_CURRENT_FOG_COORDINATE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+ {
-+ FLUSH_CURRENT(ctx, 0);
-+ params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
-+ }
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->FogCoord.Enabled);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->FogCoord.Type);
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->FogCoord.Stride;
-+ break;
-+ case GL_FOG_COORDINATE_SOURCE_EXT:
-+ CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Fog.FogCoordinateSource);
-+ break;
-+ case GL_MAX_TEXTURE_LOD_BIAS_EXT:
-+ CHECK_EXT1(EXT_texture_lod_bias, "GetIntegerv");
-+ params[0] = IROUND(ctx->Const.MaxTextureLodBias);
-+ break;
-+ case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-+ CHECK_EXT1(EXT_texture_filter_anisotropic, "GetIntegerv");
-+ params[0] = IROUND(ctx->Const.MaxTextureMaxAnisotropy);
-+ break;
-+ case GL_MULTISAMPLE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Multisample.Enabled);
-+ break;
-+ case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToCoverage);
-+ break;
-+ case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToOne);
-+ break;
-+ case GL_SAMPLE_COVERAGE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverage);
-+ break;
-+ case GL_SAMPLE_COVERAGE_VALUE_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = IROUND(ctx->Multisample.SampleCoverageValue);
-+ break;
-+ case GL_SAMPLE_COVERAGE_INVERT_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverageInvert);
-+ break;
-+ case GL_SAMPLE_BUFFERS_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = ctx->DrawBuffer->Visual.sampleBuffers;
-+ break;
-+ case GL_SAMPLES_ARB:
-+ CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+ params[0] = ctx->DrawBuffer->Visual.samples;
-+ break;
-+ case GL_RASTER_POSITION_UNCLIPPED_IBM:
-+ CHECK_EXT1(IBM_rasterpos_clip, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Transform.RasterPositionUnclipped);
-+ break;
-+ case GL_POINT_SPRITE_NV:
-+ CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Point.PointSprite);
-+ break;
-+ case GL_POINT_SPRITE_R_MODE_NV:
-+ CHECK_EXT1(NV_point_sprite, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Point.SpriteRMode);
-+ break;
-+ case GL_POINT_SPRITE_COORD_ORIGIN:
-+ CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Point.SpriteOrigin);
-+ break;
-+ case GL_GENERATE_MIPMAP_HINT_SGIS:
-+ CHECK_EXT1(SGIS_generate_mipmap, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Hint.GenerateMipmap);
-+ break;
-+ case GL_VERTEX_PROGRAM_BINDING_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = (ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY0_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY1_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[1].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY2_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[2].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY3_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[3].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[4].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY5_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[5].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY6_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[6].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY7_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[7].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY8_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[8].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY9_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[9].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY10_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[10].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY11_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[11].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY12_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[12].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY13_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[13].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY14_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[14].Enabled);
-+ break;
-+ case GL_VERTEX_ATTRIB_ARRAY15_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[15].Enabled);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[0]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[1]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[2]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[3]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[4]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[5]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[6]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[7]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[8]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[9]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[10]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[11]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[12]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[13]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[14]);
-+ break;
-+ case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-+ CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[15]);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.Enabled);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_BINDING_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetIntegerv");
-+ params[0] = ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;
-+ break;
-+ case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
-+ CHECK_EXT1(NV_fragment_program, "GetIntegerv");
-+ params[0] = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
-+ break;
-+ case GL_TEXTURE_RECTANGLE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
-+ break;
-+ case GL_TEXTURE_BINDING_RECTANGLE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-+ params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name;
-+ break;
-+ case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
-+ CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-+ params[0] = ctx->Const.MaxTextureRectSize;
-+ break;
-+ case GL_STENCIL_TEST_TWO_SIDE_EXT:
-+ CHECK_EXT1(EXT_stencil_two_side, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Stencil.TestTwoSide);
-+ break;
-+ case GL_ACTIVE_STENCIL_FACE_EXT:
-+ CHECK_EXT1(EXT_stencil_two_side, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
-+ break;
-+ case GL_MAX_SHININESS_NV:
-+ CHECK_EXT1(NV_light_max_exponent, "GetIntegerv");
-+ params[0] = IROUND(ctx->Const.MaxShininess);
-+ break;
-+ case GL_MAX_SPOT_EXPONENT_NV:
-+ CHECK_EXT1(NV_light_max_exponent, "GetIntegerv");
-+ params[0] = IROUND(ctx->Const.MaxSpotExponent);
-+ break;
-+ case GL_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayBufferObj->Name;
-+ break;
-+ case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->Vertex.BufferObj->Name;
-+ break;
-+ case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->Normal.BufferObj->Name;
-+ break;
-+ case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->Color.BufferObj->Name;
-+ break;
-+ case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->Index.BufferObj->Name;
-+ break;
-+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
-+ break;
-+ case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name;
-+ break;
-+ case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name;
-+ break;
-+ case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ArrayObj->FogCoord.BufferObj->Name;
-+ break;
-+ case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-+ CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Array.ElementArrayBufferObj->Name;
-+ break;
-+ case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_pixel_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Pack.BufferObj->Name;
-+ break;
-+ case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_pixel_buffer_object, "GetIntegerv");
-+ params[0] = ctx->Unpack.BufferObj->Name;
-+ break;
-+ case GL_VERTEX_PROGRAM_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.Enabled);
-+ break;
-+ case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.PointSizeEnabled);
-+ break;
-+ case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-+ CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.TwoSideEnabled);
-+ break;
-+ case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetIntegerv");
-+ params[0] = ctx->Const.MaxProgramMatrixStackDepth;
-+ break;
-+ case GL_MAX_PROGRAM_MATRICES_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetIntegerv");
-+ params[0] = ctx->Const.MaxProgramMatrices;
-+ break;
-+ case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->CurrentStack->Depth + 1);
-+ break;
-+ case GL_CURRENT_MATRIX_ARB:
-+ CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetIntegerv");
-+ {
-+ const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[1]);
-+ params[2] = IROUND(matrix[2]);
-+ params[3] = IROUND(matrix[3]);
-+ params[4] = IROUND(matrix[4]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[6]);
-+ params[7] = IROUND(matrix[7]);
-+ params[8] = IROUND(matrix[8]);
-+ params[9] = IROUND(matrix[9]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[11]);
-+ params[12] = IROUND(matrix[12]);
-+ params[13] = IROUND(matrix[13]);
-+ params[14] = IROUND(matrix[14]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-+ CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetIntegerv");
-+ {
-+ const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+ params[0] = IROUND(matrix[0]);
-+ params[1] = IROUND(matrix[4]);
-+ params[2] = IROUND(matrix[8]);
-+ params[3] = IROUND(matrix[12]);
-+ params[4] = IROUND(matrix[1]);
-+ params[5] = IROUND(matrix[5]);
-+ params[6] = IROUND(matrix[9]);
-+ params[7] = IROUND(matrix[13]);
-+ params[8] = IROUND(matrix[2]);
-+ params[9] = IROUND(matrix[6]);
-+ params[10] = IROUND(matrix[10]);
-+ params[11] = IROUND(matrix[14]);
-+ params[12] = IROUND(matrix[3]);
-+ params[13] = IROUND(matrix[7]);
-+ params[14] = IROUND(matrix[11]);
-+ params[15] = IROUND(matrix[15]);
-+ }
-+ break;
-+ case GL_MAX_VERTEX_ATTRIBS_ARB:
-+ CHECK_EXT1(ARB_vertex_program, "GetIntegerv");
-+ params[0] = ctx->Const.VertexProgram.MaxAttribs;
-+ break;
-+ case GL_PROGRAM_ERROR_POSITION_ARB:
-+ CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetIntegerv");
-+ params[0] = ctx->Program.ErrorPos;
-+ break;
-+ case GL_FRAGMENT_PROGRAM_ARB:
-+ CHECK_EXT1(ARB_fragment_program, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.Enabled);
-+ break;
-+ case GL_MAX_TEXTURE_COORDS_ARB:
-+ CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetIntegerv");
-+ params[0] = ctx->Const.MaxTextureCoordUnits;
-+ break;
-+ case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetIntegerv");
-+ params[0] = ctx->Const.MaxTextureImageUnits;
-+ break;
-+ case GL_DEPTH_BOUNDS_TEST_EXT:
-+ CHECK_EXT1(EXT_depth_bounds_test, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->Depth.BoundsTest);
-+ break;
-+ case GL_DEPTH_BOUNDS_EXT:
-+ CHECK_EXT1(EXT_depth_bounds_test, "GetIntegerv");
-+ params[0] = IROUND(ctx->Depth.BoundsMin);
-+ params[1] = IROUND(ctx->Depth.BoundsMax);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.CallbackEnabled);
-+ break;
-+ case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.CallbackEnabled);
-+ break;
-+ case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+ params[0] = ctx->FragmentProgram.CurrentPosition;
-+ break;
-+ case GL_VERTEX_PROGRAM_POSITION_MESA:
-+ CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+ params[0] = ctx->VertexProgram.CurrentPosition;
-+ break;
-+ case GL_MAX_DRAW_BUFFERS_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+ params[0] = ctx->Const.MaxDrawBuffers;
-+ break;
-+ case GL_DRAW_BUFFER0_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+ break;
-+ case GL_DRAW_BUFFER1_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
-+ params[0] = ENUM_TO_INT(buffer);
-+ }
-+ break;
-+ case GL_DRAW_BUFFER2_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
-+ params[0] = ENUM_TO_INT(buffer);
-+ }
-+ break;
-+ case GL_DRAW_BUFFER3_ARB:
-+ CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+ {
-+ GLenum buffer;
-+ if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+ return;
-+ }
-+ buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
-+ params[0] = ENUM_TO_INT(buffer);
-+ }
-+ break;
-+ case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-+ CHECK_EXT1(OES_read_format, "GetIntegerv");
-+ params[0] = ctx->Const.ColorReadType;
-+ break;
-+ case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-+ CHECK_EXT1(OES_read_format, "GetIntegerv");
-+ params[0] = ctx->Const.ColorReadFormat;
-+ break;
-+ case GL_NUM_FRAGMENT_REGISTERS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 6;
-+ break;
-+ case GL_NUM_FRAGMENT_CONSTANTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 8;
-+ break;
-+ case GL_NUM_PASSES_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 2;
-+ break;
-+ case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 8;
-+ break;
-+ case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 16;
-+ break;
-+ case GL_COLOR_ALPHA_PAIRING_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = BOOLEAN_TO_INT(GL_TRUE);
-+ break;
-+ case GL_NUM_LOOPBACK_COMPONENTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 3;
-+ break;
-+ case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
-+ CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+ params[0] = 3;
-+ break;
-+ case GL_STENCIL_BACK_FUNC:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.Function[1]);
-+ break;
-+ case GL_STENCIL_BACK_VALUE_MASK:
-+ params[0] = ctx->Stencil.ValueMask[1];
-+ break;
-+ case GL_STENCIL_BACK_REF:
-+ params[0] = ctx->Stencil.Ref[1];
-+ break;
-+ case GL_STENCIL_BACK_FAIL:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.FailFunc[1]);
-+ break;
-+ case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.ZFailFunc[1]);
-+ break;
-+ case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-+ params[0] = ENUM_TO_INT(ctx->Stencil.ZPassFunc[1]);
-+ break;
-+ case GL_FRAMEBUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+ params[0] = ctx->DrawBuffer->Name;
-+ break;
-+ case GL_RENDERBUFFER_BINDING_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+ params[0] = ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
-+ break;
-+ case GL_MAX_COLOR_ATTACHMENTS_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+ params[0] = ctx->Const.MaxColorAttachments;
-+ break;
-+ case GL_MAX_RENDERBUFFER_SIZE_EXT:
-+ CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+ params[0] = ctx->Const.MaxRenderbufferSize;
-+ break;
-+ case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
-+ CHECK_EXT1(ARB_fragment_shader, "GetIntegerv");
-+ params[0] = MAX_FRAGMENT_UNIFORM_COMPONENTS;
-+ break;
-+ case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-+ CHECK_EXT1(ARB_fragment_shader, "GetIntegerv");
-+ params[0] = ENUM_TO_INT(ctx->Hint.FragmentShaderDerivative);
-+ break;
-+ case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+ params[0] = MAX_VERTEX_UNIFORM_COMPONENTS;
-+ break;
-+ case GL_MAX_VARYING_FLOATS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+ params[0] = MAX_VARYING_FLOATS;
-+ break;
-+ case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+ params[0] = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-+ break;
-+ case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
-+ CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+ params[0] = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
-+ break;
-+ default:
-+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv(pname=0x%x)", pname);
-+ }
-+}
-+
-+
-+void GLAPIENTRY
-+_mesa_GetDoublev( GLenum pname, GLdouble *params )
-+{
-+ const GLfloat magic = -1234.5F;
-+ GLfloat values[16];
-+ GLuint i;
-+
-+ if (!params)
-+ return;
-+
-+ /* Init temp array to magic numbers so we can figure out how many values
-+ * are returned by the GetFloatv() call.
-+ */
-+ for (i = 0; i < 16; i++)
-+ values[i] = magic;
-+
-+ _mesa_GetFloatv(pname, values);
-+
-+ for (i = 0; i < 16 && values[i] != magic; i++)
-+ params[i] = (GLdouble) values[i];
-+}
-+
-Index: qemu-0.14.0/target-i386/mesa_gl.h
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/mesa_gl.h
-@@ -0,0 +1,2251 @@
-+/*
-+ * Mesa 3-D graphics library
-+ * Version: 6.5.1
-+ *
-+ * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a
-+ * copy of this software and associated documentation files (the "Software"),
-+ * to deal in the Software without restriction, including without limitation
-+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
-+ * and/or sell copies of the Software, and to permit persons to whom the
-+ * Software is furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included
-+ * in all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-+ */
-+
-+
-+#ifndef __gl_h_
-+#define __gl_h_
-+
-+#if defined(USE_MGL_NAMESPACE)
-+#include "gl_mangle.h"
-+#endif
-+
-+
-+/**********************************************************************
-+ * Begin system-specific stuff. Do not do any of this when building
-+ * for SciTech SNAP, as this is all done before this header file is
-+ * included.
-+ */
-+#if !defined(__SCITECH_SNAP__)
-+
-+#if defined(__BEOS__)
-+#include <stdlib.h> /* to get some BeOS-isms */
-+#endif
-+
-+#if !defined(OPENSTEP) && (defined(NeXT) || defined(NeXT_PDO))
-+#define OPENSTEP
-+#endif
-+
-+#if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__)
-+#define __WIN32__
-+#endif
-+
-+#if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__))
-+# if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */
-+# define GLAPI __declspec(dllexport)
-+# elif (defined(_MSC_VER) || defined(__MINGW32__)) && defined(_DLL) /* tag specifying we're building for DLL runtime support */
-+# define GLAPI __declspec(dllimport)
-+# else /* for use with static link lib build of Win32 edition only */
-+# define GLAPI extern
-+# endif /* _STATIC_MESA support */
-+# define GLAPIENTRY __stdcall
-+#elif defined(__CYGWIN__) && defined(USE_OPENGL32) /* use native windows opengl32 */
-+# define GLAPI extern
-+# define GLAPIENTRY __stdcall
-+#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
-+# define GLAPI __attribute__((visibility("default")))
-+# define GLAPIENTRY
-+#endif /* WIN32 && !CYGWIN */
-+
-+#if (defined(__BEOS__) && defined(__POWERPC__)) || defined(__QUICKDRAW__)
-+# define PRAGMA_EXPORT_SUPPORTED 1
-+#endif
-+
-+/*
-+ * WINDOWS: Include windows.h here to define APIENTRY.
-+ * It is also useful when applications include this file by
-+ * including only glut.h, since glut.h depends on windows.h.
-+ * Applications needing to include windows.h with parms other
-+ * than "WIN32_LEAN_AND_MEAN" may include windows.h before
-+ * glut.h or gl.h.
-+ */
-+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
-+#define WIN32_LEAN_AND_MEAN 1
-+#include <windows.h>
-+#endif
-+
-+#if defined(_WIN32) && !defined(_WINGDI_) && !defined(_GNU_H_WINDOWS32_DEFINES) && !defined(OPENSTEP) && !defined(__CYGWIN__)
-+#include <GL/mesa_wgl.h>
-+#endif
-+
-+#if defined(macintosh) && PRAGMA_IMPORT_SUPPORTED
-+#pragma import on
-+#endif
-+
-+#ifndef GLAPI
-+#define GLAPI extern
-+#endif
-+
-+#ifndef GLAPIENTRY
-+#define GLAPIENTRY
-+#endif
-+
-+#ifndef APIENTRY
-+#define APIENTRY GLAPIENTRY
-+#endif
-+
-+/* "P" suffix to be used for a pointer to a function */
-+#ifndef APIENTRYP
-+#define APIENTRYP APIENTRY *
-+#endif
-+
-+#ifndef GLAPIENTRYP
-+#define GLAPIENTRYP GLAPIENTRY *
-+#endif
-+
-+#ifdef CENTERLINE_CLPP
-+#define signed
-+#endif
-+
-+#if defined(PRAGMA_EXPORT_SUPPORTED)
-+#pragma export on
-+#endif
-+
-+#endif /* !__SCITECH_SNAP__ */
-+/*
-+ * End system-specific stuff.
-+ **********************************************************************/
-+
-+
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+
-+
-+#define GL_VERSION_1_1 1
-+#define GL_VERSION_1_2 1
-+#define GL_VERSION_1_3 1
-+#define GL_ARB_imaging 1
-+
-+
-+/*
-+ * Datatypes
-+ */
-+typedef unsigned int GLenum;
-+typedef unsigned char GLboolean;
-+typedef unsigned int GLbitfield;
-+typedef void GLvoid;
-+typedef signed char GLbyte; /* 1-byte signed */
-+typedef short GLshort; /* 2-byte signed */
-+typedef int GLint; /* 4-byte signed */
-+typedef unsigned char GLubyte; /* 1-byte unsigned */
-+typedef unsigned short GLushort; /* 2-byte unsigned */
-+typedef unsigned int GLuint; /* 4-byte unsigned */
-+typedef int GLsizei; /* 4-byte signed */
-+typedef float GLfloat; /* single precision float */
-+typedef float GLclampf; /* single precision float in [0,1] */
-+typedef double GLdouble; /* double precision float */
-+typedef double GLclampd; /* double precision float in [0,1] */
-+
-+
-+
-+/*
-+ * Constants
-+ */
-+
-+/* Boolean values */
-+#define GL_FALSE 0x0
-+#define GL_TRUE 0x1
-+
-+/* Data types */
-+#define GL_BYTE 0x1400
-+#define GL_UNSIGNED_BYTE 0x1401
-+#define GL_SHORT 0x1402
-+#define GL_UNSIGNED_SHORT 0x1403
-+#define GL_INT 0x1404
-+#define GL_UNSIGNED_INT 0x1405
-+#define GL_FLOAT 0x1406
-+#define GL_2_BYTES 0x1407
-+#define GL_3_BYTES 0x1408
-+#define GL_4_BYTES 0x1409
-+#define GL_DOUBLE 0x140A
-+
-+/* Primitives */
-+#define GL_POINTS 0x0000
-+#define GL_LINES 0x0001
-+#define GL_LINE_LOOP 0x0002
-+#define GL_LINE_STRIP 0x0003
-+#define GL_TRIANGLES 0x0004
-+#define GL_TRIANGLE_STRIP 0x0005
-+#define GL_TRIANGLE_FAN 0x0006
-+#define GL_QUADS 0x0007
-+#define GL_QUAD_STRIP 0x0008
-+#define GL_POLYGON 0x0009
-+
-+/* Vertex Arrays */
-+#define GL_VERTEX_ARRAY 0x8074
-+#define GL_NORMAL_ARRAY 0x8075
-+#define GL_COLOR_ARRAY 0x8076
-+#define GL_INDEX_ARRAY 0x8077
-+#define GL_TEXTURE_COORD_ARRAY 0x8078
-+#define GL_EDGE_FLAG_ARRAY 0x8079
-+#define GL_VERTEX_ARRAY_SIZE 0x807A
-+#define GL_VERTEX_ARRAY_TYPE 0x807B
-+#define GL_VERTEX_ARRAY_STRIDE 0x807C
-+#define GL_NORMAL_ARRAY_TYPE 0x807E
-+#define GL_NORMAL_ARRAY_STRIDE 0x807F
-+#define GL_COLOR_ARRAY_SIZE 0x8081
-+#define GL_COLOR_ARRAY_TYPE 0x8082
-+#define GL_COLOR_ARRAY_STRIDE 0x8083
-+#define GL_INDEX_ARRAY_TYPE 0x8085
-+#define GL_INDEX_ARRAY_STRIDE 0x8086
-+#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088
-+#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089
-+#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A
-+#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C
-+#define GL_VERTEX_ARRAY_POINTER 0x808E
-+#define GL_NORMAL_ARRAY_POINTER 0x808F
-+#define GL_COLOR_ARRAY_POINTER 0x8090
-+#define GL_INDEX_ARRAY_POINTER 0x8091
-+#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092
-+#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093
-+#define GL_V2F 0x2A20
-+#define GL_V3F 0x2A21
-+#define GL_C4UB_V2F 0x2A22
-+#define GL_C4UB_V3F 0x2A23
-+#define GL_C3F_V3F 0x2A24
-+#define GL_N3F_V3F 0x2A25
-+#define GL_C4F_N3F_V3F 0x2A26
-+#define GL_T2F_V3F 0x2A27
-+#define GL_T4F_V4F 0x2A28
-+#define GL_T2F_C4UB_V3F 0x2A29
-+#define GL_T2F_C3F_V3F 0x2A2A
-+#define GL_T2F_N3F_V3F 0x2A2B
-+#define GL_T2F_C4F_N3F_V3F 0x2A2C
-+#define GL_T4F_C4F_N3F_V4F 0x2A2D
-+
-+/* Matrix Mode */
-+#define GL_MATRIX_MODE 0x0BA0
-+#define GL_MODELVIEW 0x1700
-+#define GL_PROJECTION 0x1701
-+#define GL_TEXTURE 0x1702
-+
-+/* Points */
-+#define GL_POINT_SMOOTH 0x0B10
-+#define GL_POINT_SIZE 0x0B11
-+#define GL_POINT_SIZE_GRANULARITY 0x0B13
-+#define GL_POINT_SIZE_RANGE 0x0B12
-+
-+/* Lines */
-+#define GL_LINE_SMOOTH 0x0B20
-+#define GL_LINE_STIPPLE 0x0B24
-+#define GL_LINE_STIPPLE_PATTERN 0x0B25
-+#define GL_LINE_STIPPLE_REPEAT 0x0B26
-+#define GL_LINE_WIDTH 0x0B21
-+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
-+#define GL_LINE_WIDTH_RANGE 0x0B22
-+
-+/* Polygons */
-+#define GL_POINT 0x1B00
-+#define GL_LINE 0x1B01
-+#define GL_FILL 0x1B02
-+#define GL_CW 0x0900
-+#define GL_CCW 0x0901
-+#define GL_FRONT 0x0404
-+#define GL_BACK 0x0405
-+#define GL_POLYGON_MODE 0x0B40
-+#define GL_POLYGON_SMOOTH 0x0B41
-+#define GL_POLYGON_STIPPLE 0x0B42
-+#define GL_EDGE_FLAG 0x0B43
-+#define GL_CULL_FACE 0x0B44
-+#define GL_CULL_FACE_MODE 0x0B45
-+#define GL_FRONT_FACE 0x0B46
-+#define GL_POLYGON_OFFSET_FACTOR 0x8038
-+#define GL_POLYGON_OFFSET_UNITS 0x2A00
-+#define GL_POLYGON_OFFSET_POINT 0x2A01
-+#define GL_POLYGON_OFFSET_LINE 0x2A02
-+#define GL_POLYGON_OFFSET_FILL 0x8037
-+
-+/* Display Lists */
-+#define GL_COMPILE 0x1300
-+#define GL_COMPILE_AND_EXECUTE 0x1301
-+#define GL_LIST_BASE 0x0B32
-+#define GL_LIST_INDEX 0x0B33
-+#define GL_LIST_MODE 0x0B30
-+
-+/* Depth buffer */
-+#define GL_NEVER 0x0200
-+#define GL_LESS 0x0201
-+#define GL_EQUAL 0x0202
-+#define GL_LEQUAL 0x0203
-+#define GL_GREATER 0x0204
-+#define GL_NOTEQUAL 0x0205
-+#define GL_GEQUAL 0x0206
-+#define GL_ALWAYS 0x0207
-+#define GL_DEPTH_TEST 0x0B71
-+#define GL_DEPTH_BITS 0x0D56
-+#define GL_DEPTH_CLEAR_VALUE 0x0B73
-+#define GL_DEPTH_FUNC 0x0B74
-+#define GL_DEPTH_RANGE 0x0B70
-+#define GL_DEPTH_WRITEMASK 0x0B72
-+#define GL_DEPTH_COMPONENT 0x1902
-+
-+/* Lighting */
-+#define GL_LIGHTING 0x0B50
-+#define GL_LIGHT0 0x4000
-+#define GL_LIGHT1 0x4001
-+#define GL_LIGHT2 0x4002
-+#define GL_LIGHT3 0x4003
-+#define GL_LIGHT4 0x4004
-+#define GL_LIGHT5 0x4005
-+#define GL_LIGHT6 0x4006
-+#define GL_LIGHT7 0x4007
-+#define GL_SPOT_EXPONENT 0x1205
-+#define GL_SPOT_CUTOFF 0x1206
-+#define GL_CONSTANT_ATTENUATION 0x1207
-+#define GL_LINEAR_ATTENUATION 0x1208
-+#define GL_QUADRATIC_ATTENUATION 0x1209
-+#define GL_AMBIENT 0x1200
-+#define GL_DIFFUSE 0x1201
-+#define GL_SPECULAR 0x1202
-+#define GL_SHININESS 0x1601
-+#define GL_EMISSION 0x1600
-+#define GL_POSITION 0x1203
-+#define GL_SPOT_DIRECTION 0x1204
-+#define GL_AMBIENT_AND_DIFFUSE 0x1602
-+#define GL_COLOR_INDEXES 0x1603
-+#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
-+#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
-+#define GL_LIGHT_MODEL_AMBIENT 0x0B53
-+#define GL_FRONT_AND_BACK 0x0408
-+#define GL_SHADE_MODEL 0x0B54
-+#define GL_FLAT 0x1D00
-+#define GL_SMOOTH 0x1D01
-+#define GL_COLOR_MATERIAL 0x0B57
-+#define GL_COLOR_MATERIAL_FACE 0x0B55
-+#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
-+#define GL_NORMALIZE 0x0BA1
-+
-+/* User clipping planes */
-+#define GL_CLIP_PLANE0 0x3000
-+#define GL_CLIP_PLANE1 0x3001
-+#define GL_CLIP_PLANE2 0x3002
-+#define GL_CLIP_PLANE3 0x3003
-+#define GL_CLIP_PLANE4 0x3004
-+#define GL_CLIP_PLANE5 0x3005
-+
-+/* Accumulation buffer */
-+#define GL_ACCUM_RED_BITS 0x0D58
-+#define GL_ACCUM_GREEN_BITS 0x0D59
-+#define GL_ACCUM_BLUE_BITS 0x0D5A
-+#define GL_ACCUM_ALPHA_BITS 0x0D5B
-+#define GL_ACCUM_CLEAR_VALUE 0x0B80
-+#define GL_ACCUM 0x0100
-+#define GL_ADD 0x0104
-+#define GL_LOAD 0x0101
-+#define GL_MULT 0x0103
-+#define GL_RETURN 0x0102
-+
-+/* Alpha testing */
-+#define GL_ALPHA_TEST 0x0BC0
-+#define GL_ALPHA_TEST_REF 0x0BC2
-+#define GL_ALPHA_TEST_FUNC 0x0BC1
-+
-+/* Blending */
-+#define GL_BLEND 0x0BE2
-+#define GL_BLEND_SRC 0x0BE1
-+#define GL_BLEND_DST 0x0BE0
-+#define GL_ZERO 0x0
-+#define GL_ONE 0x1
-+#define GL_SRC_COLOR 0x0300
-+#define GL_ONE_MINUS_SRC_COLOR 0x0301
-+#define GL_SRC_ALPHA 0x0302
-+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
-+#define GL_DST_ALPHA 0x0304
-+#define GL_ONE_MINUS_DST_ALPHA 0x0305
-+#define GL_DST_COLOR 0x0306
-+#define GL_ONE_MINUS_DST_COLOR 0x0307
-+#define GL_SRC_ALPHA_SATURATE 0x0308
-+
-+/* Render Mode */
-+#define GL_FEEDBACK 0x1C01
-+#define GL_RENDER 0x1C00
-+#define GL_SELECT 0x1C02
-+
-+/* Feedback */
-+#define GL_2D 0x0600
-+#define GL_3D 0x0601
-+#define GL_3D_COLOR 0x0602
-+#define GL_3D_COLOR_TEXTURE 0x0603
-+#define GL_4D_COLOR_TEXTURE 0x0604
-+#define GL_POINT_TOKEN 0x0701
-+#define GL_LINE_TOKEN 0x0702
-+#define GL_LINE_RESET_TOKEN 0x0707
-+#define GL_POLYGON_TOKEN 0x0703
-+#define GL_BITMAP_TOKEN 0x0704
-+#define GL_DRAW_PIXEL_TOKEN 0x0705
-+#define GL_COPY_PIXEL_TOKEN 0x0706
-+#define GL_PASS_THROUGH_TOKEN 0x0700
-+#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0
-+#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1
-+#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2
-+
-+/* Selection */
-+#define GL_SELECTION_BUFFER_POINTER 0x0DF3
-+#define GL_SELECTION_BUFFER_SIZE 0x0DF4
-+
-+/* Fog */
-+#define GL_FOG 0x0B60
-+#define GL_FOG_MODE 0x0B65
-+#define GL_FOG_DENSITY 0x0B62
-+#define GL_FOG_COLOR 0x0B66
-+#define GL_FOG_INDEX 0x0B61
-+#define GL_FOG_START 0x0B63
-+#define GL_FOG_END 0x0B64
-+#define GL_LINEAR 0x2601
-+#define GL_EXP 0x0800
-+#define GL_EXP2 0x0801
-+
-+/* Logic Ops */
-+#define GL_LOGIC_OP 0x0BF1
-+#define GL_INDEX_LOGIC_OP 0x0BF1
-+#define GL_COLOR_LOGIC_OP 0x0BF2
-+#define GL_LOGIC_OP_MODE 0x0BF0
-+#define GL_CLEAR 0x1500
-+#define GL_SET 0x150F
-+#define GL_COPY 0x1503
-+#define GL_COPY_INVERTED 0x150C
-+#define GL_NOOP 0x1505
-+#define GL_INVERT 0x150A
-+#define GL_AND 0x1501
-+#define GL_NAND 0x150E
-+#define GL_OR 0x1507
-+#define GL_NOR 0x1508
-+#define GL_XOR 0x1506
-+#define GL_EQUIV 0x1509
-+#define GL_AND_REVERSE 0x1502
-+#define GL_AND_INVERTED 0x1504
-+#define GL_OR_REVERSE 0x150B
-+#define GL_OR_INVERTED 0x150D
-+
-+/* Stencil */
-+#define GL_STENCIL_BITS 0x0D57
-+#define GL_STENCIL_TEST 0x0B90
-+#define GL_STENCIL_CLEAR_VALUE 0x0B91
-+#define GL_STENCIL_FUNC 0x0B92
-+#define GL_STENCIL_VALUE_MASK 0x0B93
-+#define GL_STENCIL_FAIL 0x0B94
-+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
-+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
-+#define GL_STENCIL_REF 0x0B97
-+#define GL_STENCIL_WRITEMASK 0x0B98
-+#define GL_STENCIL_INDEX 0x1901
-+#define GL_KEEP 0x1E00
-+#define GL_REPLACE 0x1E01
-+#define GL_INCR 0x1E02
-+#define GL_DECR 0x1E03
-+
-+/* Buffers, Pixel Drawing/Reading */
-+#define GL_NONE 0x0
-+#define GL_LEFT 0x0406
-+#define GL_RIGHT 0x0407
-+/*GL_FRONT 0x0404 */
-+/*GL_BACK 0x0405 */
-+/*GL_FRONT_AND_BACK 0x0408 */
-+#define GL_FRONT_LEFT 0x0400
-+#define GL_FRONT_RIGHT 0x0401
-+#define GL_BACK_LEFT 0x0402
-+#define GL_BACK_RIGHT 0x0403
-+#define GL_AUX0 0x0409
-+#define GL_AUX1 0x040A
-+#define GL_AUX2 0x040B
-+#define GL_AUX3 0x040C
-+#define GL_COLOR_INDEX 0x1900
-+#define GL_RED 0x1903
-+#define GL_GREEN 0x1904
-+#define GL_BLUE 0x1905
-+#define GL_ALPHA 0x1906
-+#define GL_LUMINANCE 0x1909
-+#define GL_LUMINANCE_ALPHA 0x190A
-+#define GL_ALPHA_BITS 0x0D55
-+#define GL_RED_BITS 0x0D52
-+#define GL_GREEN_BITS 0x0D53
-+#define GL_BLUE_BITS 0x0D54
-+#define GL_INDEX_BITS 0x0D51
-+#define GL_SUBPIXEL_BITS 0x0D50
-+#define GL_AUX_BUFFERS 0x0C00
-+#define GL_READ_BUFFER 0x0C02
-+#define GL_DRAW_BUFFER 0x0C01
-+#define GL_DOUBLEBUFFER 0x0C32
-+#define GL_STEREO 0x0C33
-+#define GL_BITMAP 0x1A00
-+#define GL_COLOR 0x1800
-+#define GL_DEPTH 0x1801
-+#define GL_STENCIL 0x1802
-+#define GL_DITHER 0x0BD0
-+#define GL_RGB 0x1907
-+#define GL_RGBA 0x1908
-+
-+/* Implementation limits */
-+#define GL_MAX_LIST_NESTING 0x0B31
-+#define GL_MAX_EVAL_ORDER 0x0D30
-+#define GL_MAX_LIGHTS 0x0D31
-+#define GL_MAX_CLIP_PLANES 0x0D32
-+#define GL_MAX_TEXTURE_SIZE 0x0D33
-+#define GL_MAX_PIXEL_MAP_TABLE 0x0D34
-+#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35
-+#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36
-+#define GL_MAX_NAME_STACK_DEPTH 0x0D37
-+#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38
-+#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39
-+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
-+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B
-+
-+/* Gets */
-+#define GL_ATTRIB_STACK_DEPTH 0x0BB0
-+#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
-+#define GL_COLOR_CLEAR_VALUE 0x0C22
-+#define GL_COLOR_WRITEMASK 0x0C23
-+#define GL_CURRENT_INDEX 0x0B01
-+#define GL_CURRENT_COLOR 0x0B00
-+#define GL_CURRENT_NORMAL 0x0B02
-+#define GL_CURRENT_RASTER_COLOR 0x0B04
-+#define GL_CURRENT_RASTER_DISTANCE 0x0B09
-+#define GL_CURRENT_RASTER_INDEX 0x0B05
-+#define GL_CURRENT_RASTER_POSITION 0x0B07
-+#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
-+#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
-+#define GL_CURRENT_TEXTURE_COORDS 0x0B03
-+#define GL_INDEX_CLEAR_VALUE 0x0C20
-+#define GL_INDEX_MODE 0x0C30
-+#define GL_INDEX_WRITEMASK 0x0C21
-+#define GL_MODELVIEW_MATRIX 0x0BA6
-+#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
-+#define GL_NAME_STACK_DEPTH 0x0D70
-+#define GL_PROJECTION_MATRIX 0x0BA7
-+#define GL_PROJECTION_STACK_DEPTH 0x0BA4
-+#define GL_RENDER_MODE 0x0C40
-+#define GL_RGBA_MODE 0x0C31
-+#define GL_TEXTURE_MATRIX 0x0BA8
-+#define GL_TEXTURE_STACK_DEPTH 0x0BA5
-+#define GL_VIEWPORT 0x0BA2
-+
-+/* Evaluators */
-+#define GL_AUTO_NORMAL 0x0D80
-+#define GL_MAP1_COLOR_4 0x0D90
-+#define GL_MAP1_INDEX 0x0D91
-+#define GL_MAP1_NORMAL 0x0D92
-+#define GL_MAP1_TEXTURE_COORD_1 0x0D93
-+#define GL_MAP1_TEXTURE_COORD_2 0x0D94
-+#define GL_MAP1_TEXTURE_COORD_3 0x0D95
-+#define GL_MAP1_TEXTURE_COORD_4 0x0D96
-+#define GL_MAP1_VERTEX_3 0x0D97
-+#define GL_MAP1_VERTEX_4 0x0D98
-+#define GL_MAP2_COLOR_4 0x0DB0
-+#define GL_MAP2_INDEX 0x0DB1
-+#define GL_MAP2_NORMAL 0x0DB2
-+#define GL_MAP2_TEXTURE_COORD_1 0x0DB3
-+#define GL_MAP2_TEXTURE_COORD_2 0x0DB4
-+#define GL_MAP2_TEXTURE_COORD_3 0x0DB5
-+#define GL_MAP2_TEXTURE_COORD_4 0x0DB6
-+#define GL_MAP2_VERTEX_3 0x0DB7
-+#define GL_MAP2_VERTEX_4 0x0DB8
-+#define GL_MAP1_GRID_DOMAIN 0x0DD0
-+#define GL_MAP1_GRID_SEGMENTS 0x0DD1
-+#define GL_MAP2_GRID_DOMAIN 0x0DD2
-+#define GL_MAP2_GRID_SEGMENTS 0x0DD3
-+#define GL_COEFF 0x0A00
-+#define GL_ORDER 0x0A01
-+#define GL_DOMAIN 0x0A02
-+
-+/* Hints */
-+#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
-+#define GL_POINT_SMOOTH_HINT 0x0C51
-+#define GL_LINE_SMOOTH_HINT 0x0C52
-+#define GL_POLYGON_SMOOTH_HINT 0x0C53
-+#define GL_FOG_HINT 0x0C54
-+#define GL_DONT_CARE 0x1100
-+#define GL_FASTEST 0x1101
-+#define GL_NICEST 0x1102
-+
-+/* Scissor box */
-+#define GL_SCISSOR_BOX 0x0C10
-+#define GL_SCISSOR_TEST 0x0C11
-+
-+/* Pixel Mode / Transfer */
-+#define GL_MAP_COLOR 0x0D10
-+#define GL_MAP_STENCIL 0x0D11
-+#define GL_INDEX_SHIFT 0x0D12
-+#define GL_INDEX_OFFSET 0x0D13
-+#define GL_RED_SCALE 0x0D14
-+#define GL_RED_BIAS 0x0D15
-+#define GL_GREEN_SCALE 0x0D18
-+#define GL_GREEN_BIAS 0x0D19
-+#define GL_BLUE_SCALE 0x0D1A
-+#define GL_BLUE_BIAS 0x0D1B
-+#define GL_ALPHA_SCALE 0x0D1C
-+#define GL_ALPHA_BIAS 0x0D1D
-+#define GL_DEPTH_SCALE 0x0D1E
-+#define GL_DEPTH_BIAS 0x0D1F
-+#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1
-+#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0
-+#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2
-+#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3
-+#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4
-+#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5
-+#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6
-+#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7
-+#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8
-+#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9
-+#define GL_PIXEL_MAP_S_TO_S 0x0C71
-+#define GL_PIXEL_MAP_I_TO_I 0x0C70
-+#define GL_PIXEL_MAP_I_TO_R 0x0C72
-+#define GL_PIXEL_MAP_I_TO_G 0x0C73
-+#define GL_PIXEL_MAP_I_TO_B 0x0C74
-+#define GL_PIXEL_MAP_I_TO_A 0x0C75
-+#define GL_PIXEL_MAP_R_TO_R 0x0C76
-+#define GL_PIXEL_MAP_G_TO_G 0x0C77
-+#define GL_PIXEL_MAP_B_TO_B 0x0C78
-+#define GL_PIXEL_MAP_A_TO_A 0x0C79
-+#define GL_PACK_ALIGNMENT 0x0D05
-+#define GL_PACK_LSB_FIRST 0x0D01
-+#define GL_PACK_ROW_LENGTH 0x0D02
-+#define GL_PACK_SKIP_PIXELS 0x0D04
-+#define GL_PACK_SKIP_ROWS 0x0D03
-+#define GL_PACK_SWAP_BYTES 0x0D00
-+#define GL_UNPACK_ALIGNMENT 0x0CF5
-+#define GL_UNPACK_LSB_FIRST 0x0CF1
-+#define GL_UNPACK_ROW_LENGTH 0x0CF2
-+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
-+#define GL_UNPACK_SKIP_ROWS 0x0CF3
-+#define GL_UNPACK_SWAP_BYTES 0x0CF0
-+#define GL_ZOOM_X 0x0D16
-+#define GL_ZOOM_Y 0x0D17
-+
-+/* Texture mapping */
-+#define GL_TEXTURE_ENV 0x2300
-+#define GL_TEXTURE_ENV_MODE 0x2200
-+#define GL_TEXTURE_1D 0x0DE0
-+#define GL_TEXTURE_2D 0x0DE1
-+#define GL_TEXTURE_WRAP_S 0x2802
-+#define GL_TEXTURE_WRAP_T 0x2803
-+#define GL_TEXTURE_MAG_FILTER 0x2800
-+#define GL_TEXTURE_MIN_FILTER 0x2801
-+#define GL_TEXTURE_ENV_COLOR 0x2201
-+#define GL_TEXTURE_GEN_S 0x0C60
-+#define GL_TEXTURE_GEN_T 0x0C61
-+#define GL_TEXTURE_GEN_MODE 0x2500
-+#define GL_TEXTURE_BORDER_COLOR 0x1004
-+#define GL_TEXTURE_WIDTH 0x1000
-+#define GL_TEXTURE_HEIGHT 0x1001
-+#define GL_TEXTURE_BORDER 0x1005
-+#define GL_TEXTURE_COMPONENTS 0x1003
-+#define GL_TEXTURE_RED_SIZE 0x805C
-+#define GL_TEXTURE_GREEN_SIZE 0x805D
-+#define GL_TEXTURE_BLUE_SIZE 0x805E
-+#define GL_TEXTURE_ALPHA_SIZE 0x805F
-+#define GL_TEXTURE_LUMINANCE_SIZE 0x8060
-+#define GL_TEXTURE_INTENSITY_SIZE 0x8061
-+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
-+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
-+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
-+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
-+#define GL_OBJECT_LINEAR 0x2401
-+#define GL_OBJECT_PLANE 0x2501
-+#define GL_EYE_LINEAR 0x2400
-+#define GL_EYE_PLANE 0x2502
-+#define GL_SPHERE_MAP 0x2402
-+#define GL_DECAL 0x2101
-+#define GL_MODULATE 0x2100
-+#define GL_NEAREST 0x2600
-+#define GL_REPEAT 0x2901
-+#define GL_CLAMP 0x2900
-+#define GL_S 0x2000
-+#define GL_T 0x2001
-+#define GL_R 0x2002
-+#define GL_Q 0x2003
-+#define GL_TEXTURE_GEN_R 0x0C62
-+#define GL_TEXTURE_GEN_Q 0x0C63
-+
-+/* Utility */
-+#define GL_VENDOR 0x1F00
-+#define GL_RENDERER 0x1F01
-+#define GL_VERSION 0x1F02
-+#define GL_EXTENSIONS 0x1F03
-+
-+/* Errors */
-+#define GL_NO_ERROR 0x0
-+#define GL_INVALID_ENUM 0x0500
-+#define GL_INVALID_VALUE 0x0501
-+#define GL_INVALID_OPERATION 0x0502
-+#define GL_STACK_OVERFLOW 0x0503
-+#define GL_STACK_UNDERFLOW 0x0504
-+#define GL_OUT_OF_MEMORY 0x0505
-+
-+/* glPush/PopAttrib bits */
-+#define GL_CURRENT_BIT 0x00000001
-+#define GL_POINT_BIT 0x00000002
-+#define GL_LINE_BIT 0x00000004
-+#define GL_POLYGON_BIT 0x00000008
-+#define GL_POLYGON_STIPPLE_BIT 0x00000010
-+#define GL_PIXEL_MODE_BIT 0x00000020
-+#define GL_LIGHTING_BIT 0x00000040
-+#define GL_FOG_BIT 0x00000080
-+#define GL_DEPTH_BUFFER_BIT 0x00000100
-+#define GL_ACCUM_BUFFER_BIT 0x00000200
-+#define GL_STENCIL_BUFFER_BIT 0x00000400
-+#define GL_VIEWPORT_BIT 0x00000800
-+#define GL_TRANSFORM_BIT 0x00001000
-+#define GL_ENABLE_BIT 0x00002000
-+#define GL_COLOR_BUFFER_BIT 0x00004000
-+#define GL_HINT_BIT 0x00008000
-+#define GL_EVAL_BIT 0x00010000
-+#define GL_LIST_BIT 0x00020000
-+#define GL_TEXTURE_BIT 0x00040000
-+#define GL_SCISSOR_BIT 0x00080000
-+#define GL_ALL_ATTRIB_BITS 0x000FFFFF
-+
-+
-+/* OpenGL 1.1 */
-+#define GL_PROXY_TEXTURE_1D 0x8063
-+#define GL_PROXY_TEXTURE_2D 0x8064
-+#define GL_TEXTURE_PRIORITY 0x8066
-+#define GL_TEXTURE_RESIDENT 0x8067
-+#define GL_TEXTURE_BINDING_1D 0x8068
-+#define GL_TEXTURE_BINDING_2D 0x8069
-+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
-+#define GL_ALPHA4 0x803B
-+#define GL_ALPHA8 0x803C
-+#define GL_ALPHA12 0x803D
-+#define GL_ALPHA16 0x803E
-+#define GL_LUMINANCE4 0x803F
-+#define GL_LUMINANCE8 0x8040
-+#define GL_LUMINANCE12 0x8041
-+#define GL_LUMINANCE16 0x8042
-+#define GL_LUMINANCE4_ALPHA4 0x8043
-+#define GL_LUMINANCE6_ALPHA2 0x8044
-+#define GL_LUMINANCE8_ALPHA8 0x8045
-+#define GL_LUMINANCE12_ALPHA4 0x8046
-+#define GL_LUMINANCE12_ALPHA12 0x8047
-+#define GL_LUMINANCE16_ALPHA16 0x8048
-+#define GL_INTENSITY 0x8049
-+#define GL_INTENSITY4 0x804A
-+#define GL_INTENSITY8 0x804B
-+#define GL_INTENSITY12 0x804C
-+#define GL_INTENSITY16 0x804D
-+#define GL_R3_G3_B2 0x2A10
-+#define GL_RGB4 0x804F
-+#define GL_RGB5 0x8050
-+#define GL_RGB8 0x8051
-+#define GL_RGB10 0x8052
-+#define GL_RGB12 0x8053
-+#define GL_RGB16 0x8054
-+#define GL_RGBA2 0x8055
-+#define GL_RGBA4 0x8056
-+#define GL_RGB5_A1 0x8057
-+#define GL_RGBA8 0x8058
-+#define GL_RGB10_A2 0x8059
-+#define GL_RGBA12 0x805A
-+#define GL_RGBA16 0x805B
-+#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001
-+#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002
-+#define GL_ALL_CLIENT_ATTRIB_BITS 0xFFFFFFFF
-+#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF
-+
-+
-+
-+/*
-+ * Miscellaneous
-+ */
-+
-+GLAPI void GLAPIENTRY glClearIndex( GLfloat c );
-+
-+GLAPI void GLAPIENTRY glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
-+
-+GLAPI void GLAPIENTRY glClear( GLbitfield mask );
-+
-+GLAPI void GLAPIENTRY glIndexMask( GLuint mask );
-+
-+GLAPI void GLAPIENTRY glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
-+
-+GLAPI void GLAPIENTRY glAlphaFunc( GLenum func, GLclampf ref );
-+
-+GLAPI void GLAPIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor );
-+
-+GLAPI void GLAPIENTRY glLogicOp( GLenum opcode );
-+
-+GLAPI void GLAPIENTRY glCullFace( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glFrontFace( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glPointSize( GLfloat size );
-+
-+GLAPI void GLAPIENTRY glLineWidth( GLfloat width );
-+
-+GLAPI void GLAPIENTRY glLineStipple( GLint factor, GLushort pattern );
-+
-+GLAPI void GLAPIENTRY glPolygonMode( GLenum face, GLenum mode );
-+
-+GLAPI void GLAPIENTRY glPolygonOffset( GLfloat factor, GLfloat units );
-+
-+GLAPI void GLAPIENTRY glPolygonStipple( const GLubyte *mask );
-+
-+GLAPI void GLAPIENTRY glGetPolygonStipple( GLubyte *mask );
-+
-+GLAPI void GLAPIENTRY glEdgeFlag( GLboolean flag );
-+
-+GLAPI void GLAPIENTRY glEdgeFlagv( const GLboolean *flag );
-+
-+GLAPI void GLAPIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height);
-+
-+GLAPI void GLAPIENTRY glClipPlane( GLenum plane, const GLdouble *equation );
-+
-+GLAPI void GLAPIENTRY glGetClipPlane( GLenum plane, GLdouble *equation );
-+
-+GLAPI void GLAPIENTRY glDrawBuffer( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glReadBuffer( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glEnable( GLenum cap );
-+
-+GLAPI void GLAPIENTRY glDisable( GLenum cap );
-+
-+GLAPI GLboolean GLAPIENTRY glIsEnabled( GLenum cap );
-+
-+
-+GLAPI void GLAPIENTRY glEnableClientState( GLenum cap ); /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glDisableClientState( GLenum cap ); /* 1.1 */
-+
-+
-+GLAPI void GLAPIENTRY glGetBooleanv( GLenum pname, GLboolean *params );
-+
-+GLAPI void GLAPIENTRY glGetDoublev( GLenum pname, GLdouble *params );
-+
-+GLAPI void GLAPIENTRY glGetFloatv( GLenum pname, GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetIntegerv( GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glPushAttrib( GLbitfield mask );
-+
-+GLAPI void GLAPIENTRY glPopAttrib( void );
-+
-+
-+GLAPI void GLAPIENTRY glPushClientAttrib( GLbitfield mask ); /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glPopClientAttrib( void ); /* 1.1 */
-+
-+
-+GLAPI GLint GLAPIENTRY glRenderMode( GLenum mode );
-+
-+GLAPI GLenum GLAPIENTRY glGetError( void );
-+
-+GLAPI const GLubyte * GLAPIENTRY glGetString( GLenum name );
-+
-+GLAPI void GLAPIENTRY glFinish( void );
-+
-+GLAPI void GLAPIENTRY glFlush( void );
-+
-+GLAPI void GLAPIENTRY glHint( GLenum target, GLenum mode );
-+
-+
-+/*
-+ * Depth Buffer
-+ */
-+
-+GLAPI void GLAPIENTRY glClearDepth( GLclampd depth );
-+
-+GLAPI void GLAPIENTRY glDepthFunc( GLenum func );
-+
-+GLAPI void GLAPIENTRY glDepthMask( GLboolean flag );
-+
-+GLAPI void GLAPIENTRY glDepthRange( GLclampd near_val, GLclampd far_val );
-+
-+
-+/*
-+ * Accumulation Buffer
-+ */
-+
-+GLAPI void GLAPIENTRY glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
-+
-+GLAPI void GLAPIENTRY glAccum( GLenum op, GLfloat value );
-+
-+
-+/*
-+ * Transformation
-+ */
-+
-+GLAPI void GLAPIENTRY glMatrixMode( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glOrtho( GLdouble left, GLdouble right,
-+ GLdouble bottom, GLdouble top,
-+ GLdouble near_val, GLdouble far_val );
-+
-+GLAPI void GLAPIENTRY glFrustum( GLdouble left, GLdouble right,
-+ GLdouble bottom, GLdouble top,
-+ GLdouble near_val, GLdouble far_val );
-+
-+GLAPI void GLAPIENTRY glViewport( GLint x, GLint y,
-+ GLsizei width, GLsizei height );
-+
-+GLAPI void GLAPIENTRY glPushMatrix( void );
-+
-+GLAPI void GLAPIENTRY glPopMatrix( void );
-+
-+GLAPI void GLAPIENTRY glLoadIdentity( void );
-+
-+GLAPI void GLAPIENTRY glLoadMatrixd( const GLdouble *m );
-+GLAPI void GLAPIENTRY glLoadMatrixf( const GLfloat *m );
-+
-+GLAPI void GLAPIENTRY glMultMatrixd( const GLdouble *m );
-+GLAPI void GLAPIENTRY glMultMatrixf( const GLfloat *m );
-+
-+GLAPI void GLAPIENTRY glRotated( GLdouble angle,
-+ GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glRotatef( GLfloat angle,
-+ GLfloat x, GLfloat y, GLfloat z );
-+
-+GLAPI void GLAPIENTRY glScaled( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glScalef( GLfloat x, GLfloat y, GLfloat z );
-+
-+GLAPI void GLAPIENTRY glTranslated( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glTranslatef( GLfloat x, GLfloat y, GLfloat z );
-+
-+
-+/*
-+ * Display Lists
-+ */
-+
-+GLAPI GLboolean GLAPIENTRY glIsList( GLuint list );
-+
-+GLAPI void GLAPIENTRY glDeleteLists( GLuint list, GLsizei range );
-+
-+GLAPI GLuint GLAPIENTRY glGenLists( GLsizei range );
-+
-+GLAPI void GLAPIENTRY glNewList( GLuint list, GLenum mode );
-+
-+GLAPI void GLAPIENTRY glEndList( void );
-+
-+GLAPI void GLAPIENTRY glCallList( GLuint list );
-+
-+GLAPI void GLAPIENTRY glCallLists( GLsizei n, GLenum type,
-+ const GLvoid *lists );
-+
-+GLAPI void GLAPIENTRY glListBase( GLuint base );
-+
-+
-+/*
-+ * Drawing Functions
-+ */
-+
-+GLAPI void GLAPIENTRY glBegin( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glEnd( void );
-+
-+
-+GLAPI void GLAPIENTRY glVertex2d( GLdouble x, GLdouble y );
-+GLAPI void GLAPIENTRY glVertex2f( GLfloat x, GLfloat y );
-+GLAPI void GLAPIENTRY glVertex2i( GLint x, GLint y );
-+GLAPI void GLAPIENTRY glVertex2s( GLshort x, GLshort y );
-+
-+GLAPI void GLAPIENTRY glVertex3d( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glVertex3f( GLfloat x, GLfloat y, GLfloat z );
-+GLAPI void GLAPIENTRY glVertex3i( GLint x, GLint y, GLint z );
-+GLAPI void GLAPIENTRY glVertex3s( GLshort x, GLshort y, GLshort z );
-+
-+GLAPI void GLAPIENTRY glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
-+GLAPI void GLAPIENTRY glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
-+GLAPI void GLAPIENTRY glVertex4i( GLint x, GLint y, GLint z, GLint w );
-+GLAPI void GLAPIENTRY glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w );
-+
-+GLAPI void GLAPIENTRY glVertex2dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glVertex2fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glVertex2iv( const GLint *v );
-+GLAPI void GLAPIENTRY glVertex2sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glVertex3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glVertex3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glVertex3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glVertex3sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glVertex4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glVertex4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glVertex4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glVertex4sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz );
-+GLAPI void GLAPIENTRY glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz );
-+GLAPI void GLAPIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz );
-+GLAPI void GLAPIENTRY glNormal3i( GLint nx, GLint ny, GLint nz );
-+GLAPI void GLAPIENTRY glNormal3s( GLshort nx, GLshort ny, GLshort nz );
-+
-+GLAPI void GLAPIENTRY glNormal3bv( const GLbyte *v );
-+GLAPI void GLAPIENTRY glNormal3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glNormal3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glNormal3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glNormal3sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glIndexd( GLdouble c );
-+GLAPI void GLAPIENTRY glIndexf( GLfloat c );
-+GLAPI void GLAPIENTRY glIndexi( GLint c );
-+GLAPI void GLAPIENTRY glIndexs( GLshort c );
-+GLAPI void GLAPIENTRY glIndexub( GLubyte c ); /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glIndexdv( const GLdouble *c );
-+GLAPI void GLAPIENTRY glIndexfv( const GLfloat *c );
-+GLAPI void GLAPIENTRY glIndexiv( const GLint *c );
-+GLAPI void GLAPIENTRY glIndexsv( const GLshort *c );
-+GLAPI void GLAPIENTRY glIndexubv( const GLubyte *c ); /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glColor3b( GLbyte red, GLbyte green, GLbyte blue );
-+GLAPI void GLAPIENTRY glColor3d( GLdouble red, GLdouble green, GLdouble blue );
-+GLAPI void GLAPIENTRY glColor3f( GLfloat red, GLfloat green, GLfloat blue );
-+GLAPI void GLAPIENTRY glColor3i( GLint red, GLint green, GLint blue );
-+GLAPI void GLAPIENTRY glColor3s( GLshort red, GLshort green, GLshort blue );
-+GLAPI void GLAPIENTRY glColor3ub( GLubyte red, GLubyte green, GLubyte blue );
-+GLAPI void GLAPIENTRY glColor3ui( GLuint red, GLuint green, GLuint blue );
-+GLAPI void GLAPIENTRY glColor3us( GLushort red, GLushort green, GLushort blue );
-+
-+GLAPI void GLAPIENTRY glColor4b( GLbyte red, GLbyte green,
-+ GLbyte blue, GLbyte alpha );
-+GLAPI void GLAPIENTRY glColor4d( GLdouble red, GLdouble green,
-+ GLdouble blue, GLdouble alpha );
-+GLAPI void GLAPIENTRY glColor4f( GLfloat red, GLfloat green,
-+ GLfloat blue, GLfloat alpha );
-+GLAPI void GLAPIENTRY glColor4i( GLint red, GLint green,
-+ GLint blue, GLint alpha );
-+GLAPI void GLAPIENTRY glColor4s( GLshort red, GLshort green,
-+ GLshort blue, GLshort alpha );
-+GLAPI void GLAPIENTRY glColor4ub( GLubyte red, GLubyte green,
-+ GLubyte blue, GLubyte alpha );
-+GLAPI void GLAPIENTRY glColor4ui( GLuint red, GLuint green,
-+ GLuint blue, GLuint alpha );
-+GLAPI void GLAPIENTRY glColor4us( GLushort red, GLushort green,
-+ GLushort blue, GLushort alpha );
-+
-+
-+GLAPI void GLAPIENTRY glColor3bv( const GLbyte *v );
-+GLAPI void GLAPIENTRY glColor3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glColor3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glColor3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glColor3sv( const GLshort *v );
-+GLAPI void GLAPIENTRY glColor3ubv( const GLubyte *v );
-+GLAPI void GLAPIENTRY glColor3uiv( const GLuint *v );
-+GLAPI void GLAPIENTRY glColor3usv( const GLushort *v );
-+
-+GLAPI void GLAPIENTRY glColor4bv( const GLbyte *v );
-+GLAPI void GLAPIENTRY glColor4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glColor4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glColor4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glColor4sv( const GLshort *v );
-+GLAPI void GLAPIENTRY glColor4ubv( const GLubyte *v );
-+GLAPI void GLAPIENTRY glColor4uiv( const GLuint *v );
-+GLAPI void GLAPIENTRY glColor4usv( const GLushort *v );
-+
-+
-+GLAPI void GLAPIENTRY glTexCoord1d( GLdouble s );
-+GLAPI void GLAPIENTRY glTexCoord1f( GLfloat s );
-+GLAPI void GLAPIENTRY glTexCoord1i( GLint s );
-+GLAPI void GLAPIENTRY glTexCoord1s( GLshort s );
-+
-+GLAPI void GLAPIENTRY glTexCoord2d( GLdouble s, GLdouble t );
-+GLAPI void GLAPIENTRY glTexCoord2f( GLfloat s, GLfloat t );
-+GLAPI void GLAPIENTRY glTexCoord2i( GLint s, GLint t );
-+GLAPI void GLAPIENTRY glTexCoord2s( GLshort s, GLshort t );
-+
-+GLAPI void GLAPIENTRY glTexCoord3d( GLdouble s, GLdouble t, GLdouble r );
-+GLAPI void GLAPIENTRY glTexCoord3f( GLfloat s, GLfloat t, GLfloat r );
-+GLAPI void GLAPIENTRY glTexCoord3i( GLint s, GLint t, GLint r );
-+GLAPI void GLAPIENTRY glTexCoord3s( GLshort s, GLshort t, GLshort r );
-+
-+GLAPI void GLAPIENTRY glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q );
-+GLAPI void GLAPIENTRY glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q );
-+GLAPI void GLAPIENTRY glTexCoord4i( GLint s, GLint t, GLint r, GLint q );
-+GLAPI void GLAPIENTRY glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q );
-+
-+GLAPI void GLAPIENTRY glTexCoord1dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord1fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord1iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord1sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glTexCoord2dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord2fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord2iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord2sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glTexCoord3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord3sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glTexCoord4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord4sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glRasterPos2d( GLdouble x, GLdouble y );
-+GLAPI void GLAPIENTRY glRasterPos2f( GLfloat x, GLfloat y );
-+GLAPI void GLAPIENTRY glRasterPos2i( GLint x, GLint y );
-+GLAPI void GLAPIENTRY glRasterPos2s( GLshort x, GLshort y );
-+
-+GLAPI void GLAPIENTRY glRasterPos3d( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glRasterPos3f( GLfloat x, GLfloat y, GLfloat z );
-+GLAPI void GLAPIENTRY glRasterPos3i( GLint x, GLint y, GLint z );
-+GLAPI void GLAPIENTRY glRasterPos3s( GLshort x, GLshort y, GLshort z );
-+
-+GLAPI void GLAPIENTRY glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
-+GLAPI void GLAPIENTRY glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
-+GLAPI void GLAPIENTRY glRasterPos4i( GLint x, GLint y, GLint z, GLint w );
-+GLAPI void GLAPIENTRY glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w );
-+
-+GLAPI void GLAPIENTRY glRasterPos2dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glRasterPos2fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glRasterPos2iv( const GLint *v );
-+GLAPI void GLAPIENTRY glRasterPos2sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glRasterPos3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glRasterPos3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glRasterPos3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glRasterPos3sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glRasterPos4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glRasterPos4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glRasterPos4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glRasterPos4sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 );
-+GLAPI void GLAPIENTRY glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
-+GLAPI void GLAPIENTRY glRecti( GLint x1, GLint y1, GLint x2, GLint y2 );
-+GLAPI void GLAPIENTRY glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 );
-+
-+
-+GLAPI void GLAPIENTRY glRectdv( const GLdouble *v1, const GLdouble *v2 );
-+GLAPI void GLAPIENTRY glRectfv( const GLfloat *v1, const GLfloat *v2 );
-+GLAPI void GLAPIENTRY glRectiv( const GLint *v1, const GLint *v2 );
-+GLAPI void GLAPIENTRY glRectsv( const GLshort *v1, const GLshort *v2 );
-+
-+
-+/*
-+ * Vertex Arrays (1.1)
-+ */
-+
-+GLAPI void GLAPIENTRY glVertexPointer( GLint size, GLenum type,
-+ GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glNormalPointer( GLenum type, GLsizei stride,
-+ const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glColorPointer( GLint size, GLenum type,
-+ GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glIndexPointer( GLenum type, GLsizei stride,
-+ const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glTexCoordPointer( GLint size, GLenum type,
-+ GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glEdgeFlagPointer( GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glGetPointerv( GLenum pname, GLvoid **params );
-+
-+GLAPI void GLAPIENTRY glArrayElement( GLint i );
-+
-+GLAPI void GLAPIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count );
-+
-+GLAPI void GLAPIENTRY glDrawElements( GLenum mode, GLsizei count,
-+ GLenum type, const GLvoid *indices );
-+
-+GLAPI void GLAPIENTRY glInterleavedArrays( GLenum format, GLsizei stride,
-+ const GLvoid *pointer );
-+
-+/*
-+ * Lighting
-+ */
-+
-+GLAPI void GLAPIENTRY glShadeModel( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glLightf( GLenum light, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glLighti( GLenum light, GLenum pname, GLint param );
-+GLAPI void GLAPIENTRY glLightfv( GLenum light, GLenum pname,
-+ const GLfloat *params );
-+GLAPI void GLAPIENTRY glLightiv( GLenum light, GLenum pname,
-+ const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetLightfv( GLenum light, GLenum pname,
-+ GLfloat *params );
-+GLAPI void GLAPIENTRY glGetLightiv( GLenum light, GLenum pname,
-+ GLint *params );
-+
-+GLAPI void GLAPIENTRY glLightModelf( GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glLightModeli( GLenum pname, GLint param );
-+GLAPI void GLAPIENTRY glLightModelfv( GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glLightModeliv( GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glMateriali( GLenum face, GLenum pname, GLint param );
-+GLAPI void GLAPIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glMaterialiv( GLenum face, GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetMaterialiv( GLenum face, GLenum pname, GLint *params );
-+
-+GLAPI void GLAPIENTRY glColorMaterial( GLenum face, GLenum mode );
-+
-+
-+/*
-+ * Raster functions
-+ */
-+
-+GLAPI void GLAPIENTRY glPixelZoom( GLfloat xfactor, GLfloat yfactor );
-+
-+GLAPI void GLAPIENTRY glPixelStoref( GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glPixelStorei( GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glPixelTransferf( GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glPixelTransferi( GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glPixelMapfv( GLenum map, GLsizei mapsize,
-+ const GLfloat *values );
-+GLAPI void GLAPIENTRY glPixelMapuiv( GLenum map, GLsizei mapsize,
-+ const GLuint *values );
-+GLAPI void GLAPIENTRY glPixelMapusv( GLenum map, GLsizei mapsize,
-+ const GLushort *values );
-+
-+GLAPI void GLAPIENTRY glGetPixelMapfv( GLenum map, GLfloat *values );
-+GLAPI void GLAPIENTRY glGetPixelMapuiv( GLenum map, GLuint *values );
-+GLAPI void GLAPIENTRY glGetPixelMapusv( GLenum map, GLushort *values );
-+
-+GLAPI void GLAPIENTRY glBitmap( GLsizei width, GLsizei height,
-+ GLfloat xorig, GLfloat yorig,
-+ GLfloat xmove, GLfloat ymove,
-+ const GLubyte *bitmap );
-+
-+GLAPI void GLAPIENTRY glReadPixels( GLint x, GLint y,
-+ GLsizei width, GLsizei height,
-+ GLenum format, GLenum type,
-+ GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glDrawPixels( GLsizei width, GLsizei height,
-+ GLenum format, GLenum type,
-+ const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glCopyPixels( GLint x, GLint y,
-+ GLsizei width, GLsizei height,
-+ GLenum type );
-+
-+/*
-+ * Stenciling
-+ */
-+
-+GLAPI void GLAPIENTRY glStencilFunc( GLenum func, GLint ref, GLuint mask );
-+
-+GLAPI void GLAPIENTRY glStencilMask( GLuint mask );
-+
-+GLAPI void GLAPIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass );
-+
-+GLAPI void GLAPIENTRY glClearStencil( GLint s );
-+
-+
-+
-+/*
-+ * Texture mapping
-+ */
-+
-+GLAPI void GLAPIENTRY glTexGend( GLenum coord, GLenum pname, GLdouble param );
-+GLAPI void GLAPIENTRY glTexGenf( GLenum coord, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glTexGeni( GLenum coord, GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glTexGendv( GLenum coord, GLenum pname, const GLdouble *params );
-+GLAPI void GLAPIENTRY glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glTexGeniv( GLenum coord, GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params );
-+GLAPI void GLAPIENTRY glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetTexGeniv( GLenum coord, GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetTexEnviv( GLenum target, GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glTexParameterfv( GLenum target, GLenum pname,
-+ const GLfloat *params );
-+GLAPI void GLAPIENTRY glTexParameteriv( GLenum target, GLenum pname,
-+ const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexParameterfv( GLenum target,
-+ GLenum pname, GLfloat *params);
-+GLAPI void GLAPIENTRY glGetTexParameteriv( GLenum target,
-+ GLenum pname, GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexLevelParameterfv( GLenum target, GLint level,
-+ GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetTexLevelParameteriv( GLenum target, GLint level,
-+ GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glTexImage1D( GLenum target, GLint level,
-+ GLint internalFormat,
-+ GLsizei width, GLint border,
-+ GLenum format, GLenum type,
-+ const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glTexImage2D( GLenum target, GLint level,
-+ GLint internalFormat,
-+ GLsizei width, GLsizei height,
-+ GLint border, GLenum format, GLenum type,
-+ const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glGetTexImage( GLenum target, GLint level,
-+ GLenum format, GLenum type,
-+ GLvoid *pixels );
-+
-+
-+/* 1.1 functions */
-+
-+GLAPI void GLAPIENTRY glGenTextures( GLsizei n, GLuint *textures );
-+
-+GLAPI void GLAPIENTRY glDeleteTextures( GLsizei n, const GLuint *textures);
-+
-+GLAPI void GLAPIENTRY glBindTexture( GLenum target, GLuint texture );
-+
-+GLAPI void GLAPIENTRY glPrioritizeTextures( GLsizei n,
-+ const GLuint *textures,
-+ const GLclampf *priorities );
-+
-+GLAPI GLboolean GLAPIENTRY glAreTexturesResident( GLsizei n,
-+ const GLuint *textures,
-+ GLboolean *residences );
-+
-+GLAPI GLboolean GLAPIENTRY glIsTexture( GLuint texture );
-+
-+
-+GLAPI void GLAPIENTRY glTexSubImage1D( GLenum target, GLint level,
-+ GLint xoffset,
-+ GLsizei width, GLenum format,
-+ GLenum type, const GLvoid *pixels );
-+
-+
-+GLAPI void GLAPIENTRY glTexSubImage2D( GLenum target, GLint level,
-+ GLint xoffset, GLint yoffset,
-+ GLsizei width, GLsizei height,
-+ GLenum format, GLenum type,
-+ const GLvoid *pixels );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexImage1D( GLenum target, GLint level,
-+ GLenum internalformat,
-+ GLint x, GLint y,
-+ GLsizei width, GLint border );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexImage2D( GLenum target, GLint level,
-+ GLenum internalformat,
-+ GLint x, GLint y,
-+ GLsizei width, GLsizei height,
-+ GLint border );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexSubImage1D( GLenum target, GLint level,
-+ GLint xoffset, GLint x, GLint y,
-+ GLsizei width );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexSubImage2D( GLenum target, GLint level,
-+ GLint xoffset, GLint yoffset,
-+ GLint x, GLint y,
-+ GLsizei width, GLsizei height );
-+
-+
-+/*
-+ * Evaluators
-+ */
-+
-+GLAPI void GLAPIENTRY glMap1d( GLenum target, GLdouble u1, GLdouble u2,
-+ GLint stride,
-+ GLint order, const GLdouble *points );
-+GLAPI void GLAPIENTRY glMap1f( GLenum target, GLfloat u1, GLfloat u2,
-+ GLint stride,
-+ GLint order, const GLfloat *points );
-+
-+GLAPI void GLAPIENTRY glMap2d( GLenum target,
-+ GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
-+ GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
-+ const GLdouble *points );
-+GLAPI void GLAPIENTRY glMap2f( GLenum target,
-+ GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
-+ GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
-+ const GLfloat *points );
-+
-+GLAPI void GLAPIENTRY glGetMapdv( GLenum target, GLenum query, GLdouble *v );
-+GLAPI void GLAPIENTRY glGetMapfv( GLenum target, GLenum query, GLfloat *v );
-+GLAPI void GLAPIENTRY glGetMapiv( GLenum target, GLenum query, GLint *v );
-+
-+GLAPI void GLAPIENTRY glEvalCoord1d( GLdouble u );
-+GLAPI void GLAPIENTRY glEvalCoord1f( GLfloat u );
-+
-+GLAPI void GLAPIENTRY glEvalCoord1dv( const GLdouble *u );
-+GLAPI void GLAPIENTRY glEvalCoord1fv( const GLfloat *u );
-+
-+GLAPI void GLAPIENTRY glEvalCoord2d( GLdouble u, GLdouble v );
-+GLAPI void GLAPIENTRY glEvalCoord2f( GLfloat u, GLfloat v );
-+
-+GLAPI void GLAPIENTRY glEvalCoord2dv( const GLdouble *u );
-+GLAPI void GLAPIENTRY glEvalCoord2fv( const GLfloat *u );
-+
-+GLAPI void GLAPIENTRY glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 );
-+GLAPI void GLAPIENTRY glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 );
-+
-+GLAPI void GLAPIENTRY glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
-+ GLint vn, GLdouble v1, GLdouble v2 );
-+GLAPI void GLAPIENTRY glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
-+ GLint vn, GLfloat v1, GLfloat v2 );
-+
-+GLAPI void GLAPIENTRY glEvalPoint1( GLint i );
-+
-+GLAPI void GLAPIENTRY glEvalPoint2( GLint i, GLint j );
-+
-+GLAPI void GLAPIENTRY glEvalMesh1( GLenum mode, GLint i1, GLint i2 );
-+
-+GLAPI void GLAPIENTRY glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
-+
-+
-+/*
-+ * Fog
-+ */
-+
-+GLAPI void GLAPIENTRY glFogf( GLenum pname, GLfloat param );
-+
-+GLAPI void GLAPIENTRY glFogi( GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glFogfv( GLenum pname, const GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glFogiv( GLenum pname, const GLint *params );
-+
-+
-+/*
-+ * Selection and Feedback
-+ */
-+
-+GLAPI void GLAPIENTRY glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer );
-+
-+GLAPI void GLAPIENTRY glPassThrough( GLfloat token );
-+
-+GLAPI void GLAPIENTRY glSelectBuffer( GLsizei size, GLuint *buffer );
-+
-+GLAPI void GLAPIENTRY glInitNames( void );
-+
-+GLAPI void GLAPIENTRY glLoadName( GLuint name );
-+
-+GLAPI void GLAPIENTRY glPushName( GLuint name );
-+
-+GLAPI void GLAPIENTRY glPopName( void );
-+
-+
-+
-+/*
-+ * OpenGL 1.2
-+ */
-+
-+#define GL_RESCALE_NORMAL 0x803A
-+#define GL_CLAMP_TO_EDGE 0x812F
-+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
-+#define GL_MAX_ELEMENTS_INDICES 0x80E9
-+#define GL_BGR 0x80E0
-+#define GL_BGRA 0x80E1
-+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
-+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
-+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
-+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
-+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
-+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
-+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
-+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
-+#define GL_UNSIGNED_INT_8_8_8_8 0x8035
-+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
-+#define GL_UNSIGNED_INT_10_10_10_2 0x8036
-+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
-+#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
-+#define GL_SINGLE_COLOR 0x81F9
-+#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
-+#define GL_TEXTURE_MIN_LOD 0x813A
-+#define GL_TEXTURE_MAX_LOD 0x813B
-+#define GL_TEXTURE_BASE_LEVEL 0x813C
-+#define GL_TEXTURE_MAX_LEVEL 0x813D
-+#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
-+#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
-+#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
-+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
-+#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
-+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
-+#define GL_PACK_SKIP_IMAGES 0x806B
-+#define GL_PACK_IMAGE_HEIGHT 0x806C
-+#define GL_UNPACK_SKIP_IMAGES 0x806D
-+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
-+#define GL_TEXTURE_3D 0x806F
-+#define GL_PROXY_TEXTURE_3D 0x8070
-+#define GL_TEXTURE_DEPTH 0x8071
-+#define GL_TEXTURE_WRAP_R 0x8072
-+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
-+#define GL_TEXTURE_BINDING_3D 0x806A
-+
-+GLAPI void GLAPIENTRY glDrawRangeElements( GLenum mode, GLuint start,
-+ GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
-+
-+GLAPI void GLAPIENTRY glTexImage3D( GLenum target, GLint level,
-+ GLint internalFormat,
-+ GLsizei width, GLsizei height,
-+ GLsizei depth, GLint border,
-+ GLenum format, GLenum type,
-+ const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glTexSubImage3D( GLenum target, GLint level,
-+ GLint xoffset, GLint yoffset,
-+ GLint zoffset, GLsizei width,
-+ GLsizei height, GLsizei depth,
-+ GLenum format,
-+ GLenum type, const GLvoid *pixels);
-+
-+GLAPI void GLAPIENTRY glCopyTexSubImage3D( GLenum target, GLint level,
-+ GLint xoffset, GLint yoffset,
-+ GLint zoffset, GLint x,
-+ GLint y, GLsizei width,
-+ GLsizei height );
-+
-+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-+typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-+typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-+
-+
-+/*
-+ * GL_ARB_imaging
-+ */
-+
-+#define GL_CONSTANT_COLOR 0x8001
-+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
-+#define GL_CONSTANT_ALPHA 0x8003
-+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
-+#define GL_COLOR_TABLE 0x80D0
-+#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1
-+#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2
-+#define GL_PROXY_COLOR_TABLE 0x80D3
-+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
-+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
-+#define GL_COLOR_TABLE_SCALE 0x80D6
-+#define GL_COLOR_TABLE_BIAS 0x80D7
-+#define GL_COLOR_TABLE_FORMAT 0x80D8
-+#define GL_COLOR_TABLE_WIDTH 0x80D9
-+#define GL_COLOR_TABLE_RED_SIZE 0x80DA
-+#define GL_COLOR_TABLE_GREEN_SIZE 0x80DB
-+#define GL_COLOR_TABLE_BLUE_SIZE 0x80DC
-+#define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD
-+#define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE
-+#define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF
-+#define GL_CONVOLUTION_1D 0x8010
-+#define GL_CONVOLUTION_2D 0x8011
-+#define GL_SEPARABLE_2D 0x8012
-+#define GL_CONVOLUTION_BORDER_MODE 0x8013
-+#define GL_CONVOLUTION_FILTER_SCALE 0x8014
-+#define GL_CONVOLUTION_FILTER_BIAS 0x8015
-+#define GL_REDUCE 0x8016
-+#define GL_CONVOLUTION_FORMAT 0x8017
-+#define GL_CONVOLUTION_WIDTH 0x8018
-+#define GL_CONVOLUTION_HEIGHT 0x8019
-+#define GL_MAX_CONVOLUTION_WIDTH 0x801A
-+#define GL_MAX_CONVOLUTION_HEIGHT 0x801B
-+#define GL_POST_CONVOLUTION_RED_SCALE 0x801C
-+#define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D
-+#define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E
-+#define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F
-+#define GL_POST_CONVOLUTION_RED_BIAS 0x8020
-+#define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021
-+#define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022
-+#define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023
-+#define GL_CONSTANT_BORDER 0x8151
-+#define GL_REPLICATE_BORDER 0x8153
-+#define GL_CONVOLUTION_BORDER_COLOR 0x8154
-+#define GL_COLOR_MATRIX 0x80B1
-+#define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2
-+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3
-+#define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4
-+#define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5
-+#define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6
-+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7
-+#define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8
-+#define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9
-+#define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA
-+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB
-+#define GL_HISTOGRAM 0x8024
-+#define GL_PROXY_HISTOGRAM 0x8025
-+#define GL_HISTOGRAM_WIDTH 0x8026
-+#define GL_HISTOGRAM_FORMAT 0x8027
-+#define GL_HISTOGRAM_RED_SIZE 0x8028
-+#define GL_HISTOGRAM_GREEN_SIZE 0x8029
-+#define GL_HISTOGRAM_BLUE_SIZE 0x802A
-+#define GL_HISTOGRAM_ALPHA_SIZE 0x802B
-+#define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C
-+#define GL_HISTOGRAM_SINK 0x802D
-+#define GL_MINMAX 0x802E
-+#define GL_MINMAX_FORMAT 0x802F
-+#define GL_MINMAX_SINK 0x8030
-+#define GL_TABLE_TOO_LARGE 0x8031
-+#define GL_BLEND_EQUATION 0x8009
-+#define GL_MIN 0x8007
-+#define GL_MAX 0x8008
-+#define GL_FUNC_ADD 0x8006
-+#define GL_FUNC_SUBTRACT 0x800A
-+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
-+#define GL_BLEND_COLOR 0x8005
-+
-+
-+GLAPI void GLAPIENTRY glColorTable( GLenum target, GLenum internalformat,
-+ GLsizei width, GLenum format,
-+ GLenum type, const GLvoid *table );
-+
-+GLAPI void GLAPIENTRY glColorSubTable( GLenum target,
-+ GLsizei start, GLsizei count,
-+ GLenum format, GLenum type,
-+ const GLvoid *data );
-+
-+GLAPI void GLAPIENTRY glColorTableParameteriv(GLenum target, GLenum pname,
-+ const GLint *params);
-+
-+GLAPI void GLAPIENTRY glColorTableParameterfv(GLenum target, GLenum pname,
-+ const GLfloat *params);
-+
-+GLAPI void GLAPIENTRY glCopyColorSubTable( GLenum target, GLsizei start,
-+ GLint x, GLint y, GLsizei width );
-+
-+GLAPI void GLAPIENTRY glCopyColorTable( GLenum target, GLenum internalformat,
-+ GLint x, GLint y, GLsizei width );
-+
-+GLAPI void GLAPIENTRY glGetColorTable( GLenum target, GLenum format,
-+ GLenum type, GLvoid *table );
-+
-+GLAPI void GLAPIENTRY glGetColorTableParameterfv( GLenum target, GLenum pname,
-+ GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetColorTableParameteriv( GLenum target, GLenum pname,
-+ GLint *params );
-+
-+GLAPI void GLAPIENTRY glBlendEquation( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glBlendColor( GLclampf red, GLclampf green,
-+ GLclampf blue, GLclampf alpha );
-+
-+GLAPI void GLAPIENTRY glHistogram( GLenum target, GLsizei width,
-+ GLenum internalformat, GLboolean sink );
-+
-+GLAPI void GLAPIENTRY glResetHistogram( GLenum target );
-+
-+GLAPI void GLAPIENTRY glGetHistogram( GLenum target, GLboolean reset,
-+ GLenum format, GLenum type,
-+ GLvoid *values );
-+
-+GLAPI void GLAPIENTRY glGetHistogramParameterfv( GLenum target, GLenum pname,
-+ GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetHistogramParameteriv( GLenum target, GLenum pname,
-+ GLint *params );
-+
-+GLAPI void GLAPIENTRY glMinmax( GLenum target, GLenum internalformat,
-+ GLboolean sink );
-+
-+GLAPI void GLAPIENTRY glResetMinmax( GLenum target );
-+
-+GLAPI void GLAPIENTRY glGetMinmax( GLenum target, GLboolean reset,
-+ GLenum format, GLenum types,
-+ GLvoid *values );
-+
-+GLAPI void GLAPIENTRY glGetMinmaxParameterfv( GLenum target, GLenum pname,
-+ GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetMinmaxParameteriv( GLenum target, GLenum pname,
-+ GLint *params );
-+
-+GLAPI void GLAPIENTRY glConvolutionFilter1D( GLenum target,
-+ GLenum internalformat, GLsizei width, GLenum format, GLenum type,
-+ const GLvoid *image );
-+
-+GLAPI void GLAPIENTRY glConvolutionFilter2D( GLenum target,
-+ GLenum internalformat, GLsizei width, GLsizei height, GLenum format,
-+ GLenum type, const GLvoid *image );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameterf( GLenum target, GLenum pname,
-+ GLfloat params );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameterfv( GLenum target, GLenum pname,
-+ const GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameteri( GLenum target, GLenum pname,
-+ GLint params );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameteriv( GLenum target, GLenum pname,
-+ const GLint *params );
-+
-+GLAPI void GLAPIENTRY glCopyConvolutionFilter1D( GLenum target,
-+ GLenum internalformat, GLint x, GLint y, GLsizei width );
-+
-+GLAPI void GLAPIENTRY glCopyConvolutionFilter2D( GLenum target,
-+ GLenum internalformat, GLint x, GLint y, GLsizei width,
-+ GLsizei height);
-+
-+GLAPI void GLAPIENTRY glGetConvolutionFilter( GLenum target, GLenum format,
-+ GLenum type, GLvoid *image );
-+
-+GLAPI void GLAPIENTRY glGetConvolutionParameterfv( GLenum target, GLenum pname,
-+ GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetConvolutionParameteriv( GLenum target, GLenum pname,
-+ GLint *params );
-+
-+GLAPI void GLAPIENTRY glSeparableFilter2D( GLenum target,
-+ GLenum internalformat, GLsizei width, GLsizei height, GLenum format,
-+ GLenum type, const GLvoid *row, const GLvoid *column );
-+
-+GLAPI void GLAPIENTRY glGetSeparableFilter( GLenum target, GLenum format,
-+ GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
-+
-+typedef void (APIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
-+typedef void (APIENTRYP PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
-+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
-+typedef void (APIENTRYP PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-+typedef void (APIENTRYP PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
-+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-+typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
-+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-+typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
-+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-+typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-+typedef void (APIENTRYP PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-+typedef void (APIENTRYP PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink);
-+typedef void (APIENTRYP PFNGLRESETHISTOGRAMPROC) (GLenum target);
-+typedef void (APIENTRYP PFNGLRESETMINMAXPROC) (GLenum target);
-+
-+
-+
-+/*
-+ * OpenGL 1.3
-+ */
-+
-+/* multitexture */
-+#define GL_TEXTURE0 0x84C0
-+#define GL_TEXTURE1 0x84C1
-+#define GL_TEXTURE2 0x84C2
-+#define GL_TEXTURE3 0x84C3
-+#define GL_TEXTURE4 0x84C4
-+#define GL_TEXTURE5 0x84C5
-+#define GL_TEXTURE6 0x84C6
-+#define GL_TEXTURE7 0x84C7
-+#define GL_TEXTURE8 0x84C8
-+#define GL_TEXTURE9 0x84C9
-+#define GL_TEXTURE10 0x84CA
-+#define GL_TEXTURE11 0x84CB
-+#define GL_TEXTURE12 0x84CC
-+#define GL_TEXTURE13 0x84CD
-+#define GL_TEXTURE14 0x84CE
-+#define GL_TEXTURE15 0x84CF
-+#define GL_TEXTURE16 0x84D0
-+#define GL_TEXTURE17 0x84D1
-+#define GL_TEXTURE18 0x84D2
-+#define GL_TEXTURE19 0x84D3
-+#defin
0.15.1 has been available in OE-Core for some time and has demonstrated no major regressions, so remove the older version. Signed-off-by: Paul Eggleton <paul.eggleton@linux.intel.com> --- ...t-and-use-GCC-atomic-builtins-for-locking.patch | 86 - .../qemu/qemu-0.14.0/arm-bgr.patch | 30 - .../qemu/qemu-0.14.0/enable-i386-linux-user.patch | 55 - .../fallback-to-safe-mmap_min_addr.patch | 39 - .../qemu/qemu-0.14.0/fix-configure-checks.patch | 22 - .../qemu/qemu-0.14.0/fix-nogl.patch | 127 - .../qemu/qemu-0.14.0/glflags.patch | 15 - .../qemu/qemu-0.14.0/init-info.patch | 18 - .../qemu/qemu-0.14.0/larger_default_ram_size.patch | 22 - .../qemu/qemu-0.14.0/linker-flags.patch | 25 - .../qemu/qemu-0.14.0/no-strip.patch | 15 - .../qemu/qemu-0.14.0/opengl-sdl-fix.patch | 43 - .../qemu/qemu-0.14.0/powerpc_rom.bin | Bin 4096 -> 0 bytes .../qemu/qemu-0.14.0/qemu-git-qemugl-host.patch |34368 -------------------- .../qemu/qemu-0.14.0/qemu-vmware-vga-depth.patch | 118 - .../qemugl-allow-glxcontext-release.patch | 65 - .../qemu/qemu-0.14.0/qemugl-fix.patch | 74 - .../spice-qxl-locking-fix-for-qemu-kvm.patch | 152 - meta/recipes-devtools/qemu/qemu_0.14.0.bb | 48 - 19 files changed, 0 insertions(+), 35322 deletions(-) delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/Detect-and-use-GCC-atomic-builtins-for-locking.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/arm-bgr.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/enable-i386-linux-user.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/fallback-to-safe-mmap_min_addr.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/fix-configure-checks.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/fix-nogl.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/glflags.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/init-info.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/larger_default_ram_size.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/linker-flags.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/no-strip.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/opengl-sdl-fix.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/powerpc_rom.bin delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemu-git-qemugl-host.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemu-vmware-vga-depth.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemugl-allow-glxcontext-release.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemugl-fix.patch delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/spice-qxl-locking-fix-for-qemu-kvm.patch delete mode 100644 meta/recipes-devtools/qemu/qemu_0.14.0.bb