Patchwork [1/2] qemu: Upgrade qemu git to the latest 0.14 branch

login
register
mail settings
Submitter Zhai, Edwin
Date May 11, 2011, 2:57 a.m.
Message ID <a360279583f28b0ecea29fcbd235a3c1477ea422.1305082484.git.edwin.zhai@intel.com>
Download mbox | patch
Permalink /patch/3715/
State New, archived
Headers show

Comments

Zhai, Edwin - May 11, 2011, 2:57 a.m.
From: Zhai Edwin <edwin.zhai@intel.com>

Also add missing patch to build qemu-git

[YOCTO #1013] got fixed


Signed-off-by: Zhai Edwin <edwin.zhai@intel.com>
---
 .../qemu/qemu-git/enable-i386-linux-user.patch     |   53 +
 meta/recipes-devtools/qemu/qemu-git/fix-nogl.patch |  125 +
 .../qemu/qemu-git/linker-flags.patch               |   22 +
 meta/recipes-devtools/qemu/qemu-git/no-strip.patch |   13 +
 .../qemu/qemu-git/qemu-git-qemugl-host.patch       |34366 ++++++++++++++++++++
 .../qemu/qemu-git/qemu-vmware-vga-depth.patch      |  115 +
 .../qemu-git/qemugl-allow-glxcontext-release.patch |   63 +
 .../qemu/qemu-git/qemugl-fix.patch                 |   73 +
 meta/recipes-devtools/qemu/qemu_git.bb             |   13 +-
 9 files changed, 34837 insertions(+), 6 deletions(-)
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/enable-i386-linux-user.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/fix-nogl.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/linker-flags.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/no-strip.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/qemu-git-qemugl-host.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/qemu-vmware-vga-depth.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/qemugl-allow-glxcontext-release.patch
 create mode 100644 meta/recipes-devtools/qemu/qemu-git/qemugl-fix.patch

Patch

diff --git a/meta/recipes-devtools/qemu/qemu-git/enable-i386-linux-user.patch b/meta/recipes-devtools/qemu/qemu-git/enable-i386-linux-user.patch
new file mode 100644
index 0000000..3cf0953
--- /dev/null
+++ b/meta/recipes-devtools/qemu/qemu-git/enable-i386-linux-user.patch
@@ -0,0 +1,53 @@ 
+Enable i386-linux-user
+
+Signed-off-by: Zhai Edwin <edwin.zhai@intel.com>
+
+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)
++{
++}
diff --git a/meta/recipes-devtools/qemu/qemu-git/fix-nogl.patch b/meta/recipes-devtools/qemu/qemu-git/fix-nogl.patch
new file mode 100644
index 0000000..0219cc8
--- /dev/null
+++ b/meta/recipes-devtools/qemu/qemu-git/fix-nogl.patch
@@ -0,0 +1,125 @@ 
+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)
++{
++
++}
diff --git a/meta/recipes-devtools/qemu/qemu-git/linker-flags.patch b/meta/recipes-devtools/qemu/qemu-git/linker-flags.patch
new file mode 100644
index 0000000..470cf80
--- /dev/null
+++ b/meta/recipes-devtools/qemu/qemu-git/linker-flags.patch
@@ -0,0 +1,22 @@ 
+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
+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)
diff --git a/meta/recipes-devtools/qemu/qemu-git/no-strip.patch b/meta/recipes-devtools/qemu/qemu-git/no-strip.patch
new file mode 100644
index 0000000..cf0d659
--- /dev/null
+++ b/meta/recipes-devtools/qemu/qemu-git/no-strip.patch
@@ -0,0 +1,13 @@ 
+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)"
diff --git a/meta/recipes-devtools/qemu/qemu-git/qemu-git-qemugl-host.patch b/meta/recipes-devtools/qemu/qemu-git/qemu-git-qemugl-host.patch
new file mode 100644
index 0000000..92467a7
--- /dev/null
+++ b/meta/recipes-devtools/qemu/qemu-git/qemu-git-qemugl-host.patch
@@ -0,0 +1,34366 @@ 
+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/sh
++# 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
++#define GL_TEXTURE20				0x84D4
++#define GL_TEXTURE21				0x84D5
++#define GL_TEXTURE22				0x84D6
++#define GL_TEXTURE23				0x84D7
++#define GL_TEXTURE24				0x84D8
++#define GL_TEXTURE25				0x84D9
++#define GL_TEXTURE26				0x84DA
++#define GL_TEXTURE27				0x84DB
++#define GL_TEXTURE28				0x84DC
++#define GL_TEXTURE29				0x84DD
++#define GL_TEXTURE30				0x84DE
++#define GL_TEXTURE31				0x84DF
++#define GL_ACTIVE_TEXTURE			0x84E0
++#define GL_CLIENT_ACTIVE_TEXTURE		0x84E1
++#define GL_MAX_TEXTURE_UNITS			0x84E2
++/* texture_cube_map */
++#define GL_NORMAL_MAP				0x8511
++#define GL_REFLECTION_MAP			0x8512
++#define GL_TEXTURE_CUBE_MAP			0x8513
++#define GL_TEXTURE_BINDING_CUBE_MAP		0x8514
++#define GL_TEXTURE_CUBE_MAP_POSITIVE_X		0x8515
++#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X		0x8516
++#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y		0x8517
++#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y		0x8518
++#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z		0x8519
++#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z		0x851A
++#define GL_PROXY_TEXTURE_CUBE_MAP		0x851B
++#define GL_MAX_CUBE_MAP_TEXTURE_SIZE		0x851C
++/* texture_compression */
++#define GL_COMPRESSED_ALPHA			0x84E9
++#define GL_COMPRESSED_LUMINANCE			0x84EA
++#define GL_COMPRESSED_LUMINANCE_ALPHA		0x84EB
++#define GL_COMPRESSED_INTENSITY			0x84EC
++#define GL_COMPRESSED_RGB			0x84ED
++#define GL_COMPRESSED_RGBA			0x84EE
++#define GL_TEXTURE_COMPRESSION_HINT		0x84EF
++#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE	0x86A0
++#define GL_TEXTURE_COMPRESSED			0x86A1
++#define GL_NUM_COMPRESSED_TEXTURE_FORMATS	0x86A2
++#define GL_COMPRESSED_TEXTURE_FORMATS		0x86A3
++/* multisample */
++#define GL_MULTISAMPLE				0x809D
++#define GL_SAMPLE_ALPHA_TO_COVERAGE		0x809E
++#define GL_SAMPLE_ALPHA_TO_ONE			0x809F
++#define GL_SAMPLE_COVERAGE			0x80A0
++#define GL_SAMPLE_BUFFERS			0x80A8
++#define GL_SAMPLES				0x80A9
++#define GL_SAMPLE_COVERAGE_VALUE		0x80AA
++#define GL_SAMPLE_COVERAGE_INVERT		0x80AB
++#define GL_MULTISAMPLE_BIT			0x20000000
++/* transpose_matrix */
++#define GL_TRANSPOSE_MODELVIEW_MATRIX		0x84E3
++#define GL_TRANSPOSE_PROJECTION_MATRIX		0x84E4
++#define GL_TRANSPOSE_TEXTURE_MATRIX		0x84E5
++#define GL_TRANSPOSE_COLOR_MATRIX		0x84E6
++/* texture_env_combine */
++#define GL_COMBINE				0x8570
++#define GL_COMBINE_RGB				0x8571
++#define GL_COMBINE_ALPHA			0x8572
++#define GL_SOURCE0_RGB				0x8580
++#define GL_SOURCE1_RGB				0x8581
++#define GL_SOURCE2_RGB				0x8582
++#define GL_SOURCE0_ALPHA			0x8588
++#define GL_SOURCE1_ALPHA			0x8589
++#define GL_SOURCE2_ALPHA			0x858A
++#define GL_OPERAND0_RGB				0x8590
++#define GL_OPERAND1_RGB				0x8591
++#define GL_OPERAND2_RGB				0x8592
++#define GL_OPERAND0_ALPHA			0x8598
++#define GL_OPERAND1_ALPHA			0x8599
++#define GL_OPERAND2_ALPHA			0x859A
++#define GL_RGB_SCALE				0x8573
++#define GL_ADD_SIGNED				0x8574
++#define GL_INTERPOLATE				0x8575
++#define GL_SUBTRACT				0x84E7
++#define GL_CONSTANT				0x8576
++#define GL_PRIMARY_COLOR			0x8577
++#define GL_PREVIOUS				0x8578
++/* texture_env_dot3 */
++#define GL_DOT3_RGB				0x86AE
++#define GL_DOT3_RGBA				0x86AF
++/* texture_border_clamp */
++#define GL_CLAMP_TO_BORDER			0x812D
++
++GLAPI void GLAPIENTRY glActiveTexture( GLenum texture );
++
++GLAPI void GLAPIENTRY glClientActiveTexture( GLenum texture );
++
++GLAPI void GLAPIENTRY glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data );
++
++GLAPI void GLAPIENTRY glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data );
++
++GLAPI void GLAPIENTRY glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data );
++
++GLAPI void GLAPIENTRY glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
++
++GLAPI void GLAPIENTRY glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
++
++GLAPI void GLAPIENTRY glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data );
++
++GLAPI void GLAPIENTRY glGetCompressedTexImage( GLenum target, GLint lod, GLvoid *img );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1d( GLenum target, GLdouble s );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1dv( GLenum target, const GLdouble *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1f( GLenum target, GLfloat s );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1fv( GLenum target, const GLfloat *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1i( GLenum target, GLint s );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1iv( GLenum target, const GLint *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1s( GLenum target, GLshort s );
++
++GLAPI void GLAPIENTRY glMultiTexCoord1sv( GLenum target, const GLshort *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2dv( GLenum target, const GLdouble *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2fv( GLenum target, const GLfloat *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2i( GLenum target, GLint s, GLint t );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2iv( GLenum target, const GLint *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2s( GLenum target, GLshort s, GLshort t );
++
++GLAPI void GLAPIENTRY glMultiTexCoord2sv( GLenum target, const GLshort *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3dv( GLenum target, const GLdouble *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3fv( GLenum target, const GLfloat *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3iv( GLenum target, const GLint *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r );
++
++GLAPI void GLAPIENTRY glMultiTexCoord3sv( GLenum target, const GLshort *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4dv( GLenum target, const GLdouble *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4fv( GLenum target, const GLfloat *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4iv( GLenum target, const GLint *v );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
++
++GLAPI void GLAPIENTRY glMultiTexCoord4sv( GLenum target, const GLshort *v );
++
++
++GLAPI void GLAPIENTRY glLoadTransposeMatrixd( const GLdouble m[16] );
++
++GLAPI void GLAPIENTRY glLoadTransposeMatrixf( const GLfloat m[16] );
++
++GLAPI void GLAPIENTRY glMultTransposeMatrixd( const GLdouble m[16] );
++
++GLAPI void GLAPIENTRY glMultTransposeMatrixf( const GLfloat m[16] );
++
++GLAPI void GLAPIENTRY glSampleCoverage( GLclampf value, GLboolean invert );
++
++typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
++typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v);
++typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m);
++typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m);
++typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m);
++typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m);
++typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert);
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
++typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, void *img);
++
++
++/*
++ * GL_ARB_multitexture (ARB extension 1 and OpenGL 1.2.1)
++ */
++#ifndef GL_ARB_multitexture
++#define GL_ARB_multitexture 1
++
++#define GL_TEXTURE0_ARB				0x84C0
++#define GL_TEXTURE1_ARB				0x84C1
++#define GL_TEXTURE2_ARB				0x84C2
++#define GL_TEXTURE3_ARB				0x84C3
++#define GL_TEXTURE4_ARB				0x84C4
++#define GL_TEXTURE5_ARB				0x84C5
++#define GL_TEXTURE6_ARB				0x84C6
++#define GL_TEXTURE7_ARB				0x84C7
++#define GL_TEXTURE8_ARB				0x84C8
++#define GL_TEXTURE9_ARB				0x84C9
++#define GL_TEXTURE10_ARB			0x84CA
++#define GL_TEXTURE11_ARB			0x84CB
++#define GL_TEXTURE12_ARB			0x84CC
++#define GL_TEXTURE13_ARB			0x84CD
++#define GL_TEXTURE14_ARB			0x84CE
++#define GL_TEXTURE15_ARB			0x84CF
++#define GL_TEXTURE16_ARB			0x84D0
++#define GL_TEXTURE17_ARB			0x84D1
++#define GL_TEXTURE18_ARB			0x84D2
++#define GL_TEXTURE19_ARB			0x84D3
++#define GL_TEXTURE20_ARB			0x84D4
++#define GL_TEXTURE21_ARB			0x84D5
++#define GL_TEXTURE22_ARB			0x84D6
++#define GL_TEXTURE23_ARB			0x84D7
++#define GL_TEXTURE24_ARB			0x84D8
++#define GL_TEXTURE25_ARB			0x84D9
++#define GL_TEXTURE26_ARB			0x84DA
++#define GL_TEXTURE27_ARB			0x84DB
++#define GL_TEXTURE28_ARB			0x84DC
++#define GL_TEXTURE29_ARB			0x84DD
++#define GL_TEXTURE30_ARB			0x84DE
++#define GL_TEXTURE31_ARB			0x84DF
++#define GL_ACTIVE_TEXTURE_ARB			0x84E0
++#define GL_CLIENT_ACTIVE_TEXTURE_ARB		0x84E1
++#define GL_MAX_TEXTURE_UNITS_ARB		0x84E2
++
++GLAPI void GLAPIENTRY glActiveTextureARB(GLenum texture);
++GLAPI void GLAPIENTRY glClientActiveTextureARB(GLenum texture);
++GLAPI void GLAPIENTRY glMultiTexCoord1dARB(GLenum target, GLdouble s);
++GLAPI void GLAPIENTRY glMultiTexCoord1dvARB(GLenum target, const GLdouble *v);
++GLAPI void GLAPIENTRY glMultiTexCoord1fARB(GLenum target, GLfloat s);
++GLAPI void GLAPIENTRY glMultiTexCoord1fvARB(GLenum target, const GLfloat *v);
++GLAPI void GLAPIENTRY glMultiTexCoord1iARB(GLenum target, GLint s);
++GLAPI void GLAPIENTRY glMultiTexCoord1ivARB(GLenum target, const GLint *v);
++GLAPI void GLAPIENTRY glMultiTexCoord1sARB(GLenum target, GLshort s);
++GLAPI void GLAPIENTRY glMultiTexCoord1svARB(GLenum target, const GLshort *v);