new file mode 100644
@@ -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)
++{
++}
new file mode 100644
@@ -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)
++{
++
++}
new file mode 100644
@@ -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)
new file mode 100644
@@ -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)"
new file mode 100644
@@ -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