Added missing filesHEADmaster

205 files changed, 147354 insertions, 0 deletions

diff --git a/src/mesa/Makefile b/src/mesa/Makefile
new file mode 100644
index 0000000..bf600e0
--- /dev/null
+++ b/src/mesa/Makefile
@@ -0,0 +1,179 @@
+# src/mesa/Makefile
+
+TOP = ../..
+include $(TOP)/configs/current
+
+include sources
+
+
+GL_MAJOR = 1
+GL_MINOR = 5
+GL_TINY = 0$(MESA_MAJOR)0$(MESA_MINOR)0$(MESA_TINY)
+
+
+.SUFFIXES : .cpp
+
+.c.o:
+	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+
+.cpp.o:
+	$(CXX) -c $(INCLUDE_DIRS) $(CXXFLAGS) $< -o $@
+
+.S.o:
+	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+
+
+# Figure out what to make here
+default:
+	@if [ "${DRIVER_DIRS}" = "dri" ] ; then \
+		$(MAKE) linux-solo ; \
+	elif [ "${DRIVER_DIRS}" = "osmesa" ] ; then \
+		$(MAKE) osmesa-only ; \
+	elif [ "$(DRIVER_DIRS)" = "beos" ]; then \
+		$(MAKE) beos ; \
+	elif [ "$(DRIVER_DIRS)" = "directfb" ]; then \
+		$(MAKE) directfb; \
+	else \
+		$(MAKE) stand-alone ; \
+	fi
+
+
+
+######################################################################
+# BeOS driver target
+
+beos: depend subdirs libmesa.a
+	cd drivers/beos; $(MAKE)
+
+
+######################################################################
+# Linux DRI drivers
+
+# Make archive of core object files
+libmesa.a: $(SOLO_OBJECTS)
+	@ $(TOP)/bin/mklib -o mesa -static $(SOLO_OBJECTS);
+	@if [ "${CONFIG_NAME}" = "beos" ] ; then \
+		mimeset -f "$@" ; \
+	fi
+
+linux-solo: depend subdirs libmesa.a
+	cd drivers/dri ; $(MAKE)
+
+
+#####################################################################
+# Stand-alone Mesa libGL, no built-in drivers (DirectFB)
+
+libgl-core: $(CORE_OBJECTS)
+	@ $(TOP)/bin/mklib -o $(GL_LIB) -linker '$(CC)' \
+		-major $(MESA_MAJOR) -minor $(MESA_MINOR) -patch $(MESA_TINY) \
+		-install $(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) $(CORE_OBJECTS) $(GL_LIB_DEPS)
+
+directfb: depend subdirs libgl-core
+	cd drivers/directfb; $(MAKE)
+
+
+######################################################################
+# Stand-alone Mesa libGL and libOSMesa
+
+STAND_ALONE_DRIVER_SOURCES = \
+	$(COMMON_DRIVER_SOURCES) \
+	$(X11_DRIVER_SOURCES) \
+	$(GLIDE_DRIVER_SOURCES) \
+	$(SVGA_DRIVER_SOURCES) \
+	$(FBDEV_DRIVER_SOURCES)
+
+STAND_ALONE_DRIVER_OBJECTS = $(STAND_ALONE_DRIVER_SOURCES:.c=.o)
+
+STAND_ALONE_OBJECTS = \
+	$(CORE_OBJECTS) \
+	$(STAND_ALONE_DRIVER_OBJECTS)
+
+# For libOSMesa16 or libOSMesa32 we link _all_ the objects into the library,
+# not just the osmesa.o object (i.e. we don't have a libGL).
+OSMESA16_OBJECTS = \
+	$(CORE_OBJECTS) \
+	$(COMMON_DRIVER_OBJECTS) \
+	$(OSMESA_DRIVER_OBJECTS)
+
+
+stand-alone: depend subdirs $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_NAME)
+
+osmesa-only: depend subdirs $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_NAME)
+
+# Make the GL library
+$(TOP)/$(LIB_DIR)/$(GL_LIB_NAME): $(STAND_ALONE_OBJECTS)
+	@ $(TOP)/bin/mklib -o $(GL_LIB) -linker '$(CC)' \
+		-major $(GL_MAJOR) -minor $(GL_MINOR) -patch $(GL_TINY) \
+		-install $(TOP)/$(LIB_DIR) \
+		$(MKLIB_OPTIONS) $(GL_LIB_DEPS) $(STAND_ALONE_OBJECTS)
+
+# Make the OSMesa library
+$(TOP)/$(LIB_DIR)/$(OSMESA_LIB_NAME): $(OSMESA_DRIVER_OBJECTS) $(OSMESA16_OBJECTS)
+	@ if [ "${DRIVER_DIRS}" = "osmesa" ] ; then \
+		$(TOP)/bin/mklib -o $(OSMESA_LIB) -linker '$(CC)' \
+			-major $(MESA_MAJOR) \
+			-minor $(MESA_MINOR) -patch $(MESA_TINY) \
+			-install $(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) \
+			$(OSMESA_LIB_DEPS) $(OSMESA16_OBJECTS) ; \
+	else \
+		$(TOP)/bin/mklib -o $(OSMESA_LIB) -linker '$(CC)' \
+			-major $(MESA_MAJOR) \
+			-minor $(MESA_MINOR) -patch $(GL_TINY) \
+			-install $(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) \
+			$(OSMESA_LIB_DEPS) $(OSMESA_DRIVER_OBJECTS) ; \
+	fi
+
+
+######################################################################
+# Generic stuff
+
+ALL_SOURCES = \
+	$(GLAPI_SOURCES)	\
+	$(SOLO_SOURCES)		\
+	$(X86_SOURCES)		\
+	$(COMMON_DRIVER_SOURCES)\
+	$(X11_DRIVER_SOURCES)	\
+	$(OSMESA_DRIVER_SOURCES)
+
+
+depend: $(ALL_SOURCES)
+	@ echo "running $(MKDEP)"
+	@ touch depend
+	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDE_DIRS) $(ALL_SOURCES) \
+		> /dev/null 
+
+
+subdirs:
+	@ (cd x86 ; $(MAKE))
+	@ (cd x86-64 ; $(MAKE))
+
+
+install: default
+	$(INSTALL) -d $(INSTALL_DIR)/include/GL
+	$(INSTALL) -d $(INSTALL_DIR)/$(LIB_DIR)
+	$(INSTALL) -m 644 $(TOP)/include/GL/*.h $(INSTALL_DIR)/include/GL
+	$(COPY_LIBS) $(TOP)/$(LIB_DIR)/libGL.* $(INSTALL_DIR)/$(LIB_DIR)
+	@if [ "${DRIVER_DIRS}" = "dri" ] ; then \
+		cd drivers/dri ; $(MAKE) install ; \
+	fi
+
+
+	## NOT YET:
+	## $(INSTALL) -d $(INSTALL_DIR)/include/GLES
+	## $(INSTALL) -m 644 include/GLES/*.h $(INSTALL_DIR)/include/GLES
+
+
+# Emacs tags
+tags:
+	etags `find . -name \*.[ch]` $(TOP)/include/GL/*.h
+
+clean:
+	-rm -f */*.o
+	-rm -f */*/*.o
+	-rm -f depend depend.bak libmesa.a
+	-rm -f drivers/*/*.o
+	(cd drivers/dri ; $(MAKE) clean)
+	(cd x86 ; $(MAKE) clean)
+	(cd x86-64 ; $(MAKE) clean)
+
+include depend
diff --git a/src/mesa/drivers/dri/common/depthtmp.h b/src/mesa/drivers/dri/common/depthtmp.h
new file mode 100644
index 0000000..55199ab
--- /dev/null
+++ b/src/mesa/drivers/dri/common/depthtmp.h
@@ -0,0 +1,269 @@
+
+/*
+ * Notes:
+ * 1. These functions plug into the gl_renderbuffer structure.
+ * 2. The 'values' parameter always points to GLuint values, regardless of
+ *    the actual Z buffer depth.
+ */
+
+
+#include "spantmp_common.h"
+
+#ifndef DBG
+#define DBG 0
+#endif
+
+#ifndef HAVE_HW_DEPTH_SPANS
+#define HAVE_HW_DEPTH_SPANS 0
+#endif
+
+#ifndef HAVE_HW_DEPTH_PIXELS
+#define HAVE_HW_DEPTH_PIXELS 0
+#endif
+
+static void TAG(WriteDepthSpan)( GLcontext *ctx,
+                                 struct gl_renderbuffer *rb,
+                                 GLuint n, GLint x, GLint y,
+				 const void *values,
+				 const GLubyte mask[] )
+{
+   HW_WRITE_LOCK()
+      {
+         const GLuint *depth = (const GLuint *) values;
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_DEPTH_VARS;
+
+	 y = Y_FLIP( y );
+
+#if HAVE_HW_DEPTH_SPANS
+	 (void) x1; (void) n1;
+
+	 if ( DBG ) fprintf( stderr, "WriteDepthSpan 0..%d (x1 %d)\n",
+			     (int)n, (int)x );
+
+	 WRITE_DEPTH_SPAN();
+#else
+	 HW_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN( x, y, n, x1, n1, i );
+
+	       if ( DBG ) fprintf( stderr, "WriteDepthSpan %d..%d (x1 %d) (mask %p)\n",
+				   (int)i, (int)n1, (int)x1, mask );
+
+	       if ( mask ) {
+		  for ( ; n1>0 ; i++, x1++, n1-- ) {
+		     if ( mask[i] ) WRITE_DEPTH( x1, y, depth[i] );
+		  }
+	       } else {
+		  for ( ; n1>0 ; i++, x1++, n1-- ) {
+		     WRITE_DEPTH( x1, y, depth[i] );
+		  }
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+#endif
+      }
+   HW_WRITE_UNLOCK();
+}
+
+
+#if HAVE_HW_DEPTH_SPANS
+/* implement MonoWriteDepthSpan() in terms of WriteDepthSpan() */
+static void
+TAG(WriteMonoDepthSpan)( GLcontext *ctx, struct gl_renderbuffer *rb,
+                         GLuint n, GLint x, GLint y,
+                         const void *value, const GLubyte mask[] )
+{
+   const GLuint depthVal = *((GLuint *) value);
+   GLuint depths[MAX_WIDTH];
+   GLuint i;
+   for (i = 0; i < n; i++)
+      depths[i] = depthVal;
+   TAG(WriteDepthSpan)(ctx, rb, n, x, y, depths, mask);
+}
+#else
+static void TAG(WriteMonoDepthSpan)( GLcontext *ctx,
+                                     struct gl_renderbuffer *rb,
+                                     GLuint n, GLint x, GLint y,
+                                     const void *value,
+                                     const GLubyte mask[] )
+{
+   HW_WRITE_LOCK()
+      {
+         const GLuint depth = *((GLuint *) value);
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_DEPTH_VARS;
+
+	 y = Y_FLIP( y );
+
+	 HW_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN( x, y, n, x1, n1, i );
+
+	       if ( DBG ) fprintf( stderr, "%s %d..%d (x1 %d) = %u\n",
+				   __FUNCTION__, (int)i, (int)n1, (int)x1, (GLuint)depth );
+
+	       if ( mask ) {
+		  for ( ; n1>0 ; i++, x1++, n1-- ) {
+		     if ( mask[i] ) WRITE_DEPTH( x1, y, depth );
+		  }
+	       } else {
+		  for ( ; n1>0 ; x1++, n1-- ) {
+		     WRITE_DEPTH( x1, y, depth );
+		  }
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_WRITE_UNLOCK();
+}
+#endif
+
+
+static void TAG(WriteDepthPixels)( GLcontext *ctx,
+                                   struct gl_renderbuffer *rb,
+				   GLuint n,
+				   const GLint x[],
+				   const GLint y[],
+				   const void *values,
+				   const GLubyte mask[] )
+{
+   HW_WRITE_LOCK()
+      {
+         const GLuint *depth = (const GLuint *) values;
+	 GLuint i;
+	 LOCAL_DEPTH_VARS;
+
+	 if ( DBG ) fprintf( stderr, "WriteDepthPixels\n" );
+
+#if HAVE_HW_DEPTH_PIXELS
+	 (void) i;
+
+	 WRITE_DEPTH_PIXELS();
+#else
+	 HW_CLIPLOOP()
+	    {
+	       if ( mask ) {
+		  for ( i = 0 ; i < n ; i++ ) {
+		     if ( mask[i] ) {
+			const int fy = Y_FLIP( y[i] );
+			if ( CLIPPIXEL( x[i], fy ) )
+			   WRITE_DEPTH( x[i], fy, depth[i] );
+		     }
+		  }
+	       }
+	       else {
+		  for ( i = 0 ; i < n ; i++ ) {
+		     const int fy = Y_FLIP( y[i] );
+		     if ( CLIPPIXEL( x[i], fy ) )
+			WRITE_DEPTH( x[i], fy, depth[i] );
+		  }
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+#endif
+      }
+   HW_WRITE_UNLOCK();
+}
+
+
+/* Read depth spans and pixels
+ */
+static void TAG(ReadDepthSpan)( GLcontext *ctx,
+                                struct gl_renderbuffer *rb,
+				GLuint n, GLint x, GLint y,
+				void *values )
+{
+   HW_READ_LOCK()
+      {
+         GLuint *depth = (GLuint *) values;
+	 GLint x1, n1;
+	 LOCAL_DEPTH_VARS;
+
+	 y = Y_FLIP( y );
+
+	 if ( DBG ) fprintf( stderr, "ReadDepthSpan\n" );
+
+#if HAVE_HW_DEPTH_SPANS
+	 (void) x1; (void) n1;
+
+	 READ_DEPTH_SPAN();
+#else
+	 HW_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN( x, y, n, x1, n1, i );
+	       for ( ; n1>0 ; i++, n1-- ) {
+		  READ_DEPTH( depth[i], x+i, y );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+#endif
+      }
+   HW_READ_UNLOCK();
+}
+
+static void TAG(ReadDepthPixels)( GLcontext *ctx,
+                                  struct gl_renderbuffer *rb,
+                                  GLuint n,
+				  const GLint x[], const GLint y[],
+				  void *values )
+{
+   HW_READ_LOCK()
+      {
+         GLuint *depth = (GLuint *) values;
+	 GLuint i;
+	 LOCAL_DEPTH_VARS;
+
+	 if ( DBG ) fprintf( stderr, "ReadDepthPixels\n" );
+
+#if HAVE_HW_DEPTH_PIXELS
+	 (void) i;
+
+	 READ_DEPTH_PIXELS();
+#else
+	 HW_CLIPLOOP()
+	    {
+	       for ( i = 0 ; i < n ;i++ ) {
+		  int fy = Y_FLIP( y[i] );
+		  if ( CLIPPIXEL( x[i], fy ) )
+		     READ_DEPTH( depth[i], x[i], fy );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+#endif
+      }
+   HW_READ_UNLOCK();
+}
+
+
+/**
+ * Initialize the given renderbuffer's span routines to point to
+ * the depth/z functions we generated above.
+ */
+static void TAG(InitDepthPointers)(struct gl_renderbuffer *rb)
+{
+   rb->GetRow = TAG(ReadDepthSpan);
+   rb->GetValues = TAG(ReadDepthPixels);
+   rb->PutRow = TAG(WriteDepthSpan);
+   rb->PutRowRGB = NULL;
+   rb->PutMonoRow = TAG(WriteMonoDepthSpan);
+   rb->PutValues = TAG(WriteDepthPixels);
+   rb->PutMonoValues = NULL;
+}
+
+
+#if HAVE_HW_DEPTH_SPANS
+#undef WRITE_DEPTH_SPAN
+#undef WRITE_DEPTH_PIXELS
+#undef READ_DEPTH_SPAN
+#undef READ_DEPTH_PIXELS
+#else
+#undef WRITE_DEPTH
+#undef READ_DEPTH
+#endif
+#undef TAG
diff --git a/src/mesa/drivers/dri/common/dri_util.c b/src/mesa/drivers/dri/common/dri_util.c
new file mode 100644
index 0000000..b5c20a0
--- /dev/null
+++ b/src/mesa/drivers/dri/common/dri_util.c
@@ -0,0 +1,1093 @@
+/* $XFree86: xc/lib/GL/dri/dri_util.c,v 1.7 2003/04/28 17:01:25 dawes Exp $ */
+/**
+ * \file dri_util.c
+ * DRI utility functions.
+ *
+ * This module acts as glue between GLX and the actual hardware driver.  A DRI
+ * driver doesn't really \e have to use any of this - it's optional.  But, some
+ * useful stuff is done here that otherwise would have to be duplicated in most
+ * drivers.
+ * 
+ * Basically, these utility functions take care of some of the dirty details of
+ * screen initialization, context creation, context binding, DRM setup, etc.
+ *
+ * These functions are compiled into each DRI driver so libGL.so knows nothing
+ * about them.
+ */
+
+
+#include <assert.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdio.h>
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *)-1)
+#endif
+
+#include "imports.h"
+#define None 0
+
+#include "dri_util.h"
+#include "drm_sarea.h"
+
+#ifndef GLX_OML_sync_control
+typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRInativeDisplay *dpy, __DRIid drawable, int32_t *numerator, int32_t *denominator);
+#endif
+
+/* This pointer *must* be set by the driver's __driCreateNewScreen funciton!
+ */
+const __DRIinterfaceMethods * dri_interface = NULL;
+
+/**
+ * This is used in a couple of places that call \c driCreateNewDrawable.
+ */
+static const int empty_attribute_list[1] = { None };
+
+
+/**
+ * Cached copy of the internal API version used by libGL and the client-side
+ * DRI driver.
+ */
+static int api_ver = 0;
+
+/* forward declarations */
+static int driQueryFrameTracking( __DRInativeDisplay *dpy, void *priv,
+                                  int64_t *sbc, int64_t *missedFrames,
+                                  float *lastMissedUsage, float *usage );
+
+static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
+                                  const __GLcontextModes *modes,
+                                  __DRIid draw, __DRIdrawable *pdraw,
+                                  int renderType, const int *attrs);
+
+static void driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate);
+
+
+/**
+ * Print message to \c stderr if the \c LIBGL_DEBUG environment variable
+ * is set. 
+ * 
+ * Is called from the drivers.
+ * 
+ * \param f \c printf like format string.
+ */
+void
+__driUtilMessage(const char *f, ...)
+{
+    va_list args;
+
+    if (getenv("LIBGL_DEBUG")) {
+        fprintf(stderr, "libGL error: \n");
+        va_start(args, f);
+        vfprintf(stderr, f, args);
+        va_end(args);
+        fprintf(stderr, "\n");
+    }
+}
+
+
+/*****************************************************************/
+/** \name Drawable list management */
+/*****************************************************************/
+/*@{*/
+
+static GLboolean __driAddDrawable(void *drawHash, __DRIdrawable *pdraw)
+{
+    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
+
+    if (drmHashInsert(drawHash, pdp->draw, pdraw))
+	return GL_FALSE;
+
+    return GL_TRUE;
+}
+
+static __DRIdrawable *__driFindDrawable(void *drawHash, __DRIid draw)
+{
+    int retcode;
+    __DRIdrawable *pdraw;
+
+    retcode = drmHashLookup(drawHash, draw, (void *)&pdraw);
+    if (retcode)
+	return NULL;
+
+    return pdraw;
+}
+
+
+/**
+ * Find drawables in the local hash that have been destroyed on the
+ * server.
+ * 
+ * \param drawHash  Hash-table containing all know drawables.
+ */
+static void __driGarbageCollectDrawables(void *drawHash)
+{
+    __DRIid draw;
+    __DRInativeDisplay *dpy;
+    __DRIdrawable *pdraw;
+
+    if (drmHashFirst(drawHash, &draw, (void *)&pdraw) == 1) {
+	do {
+	    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
+	    dpy = pdp->driScreenPriv->display;
+	    if (! (*dri_interface->windowExists)(dpy, draw)) {
+		/* Destroy the local drawable data, if the drawable no
+		   longer exists in the Xserver */
+		(*pdraw->destroyDrawable)(dpy, pdraw->private);
+		_mesa_free(pdraw);
+	    }
+	} while (drmHashNext(drawHash, &draw, (void *)&pdraw) == 1);
+    }
+}
+
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Context (un)binding functions                          */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Unbind context.
+ * 
+ * \param dpy the display handle.
+ * \param scrn the screen number.
+ * \param draw drawable.
+ * \param read Current reading drawable.
+ * \param gc context.
+ *
+ * \return \c GL_TRUE on success, or \c GL_FALSE on failure.
+ * 
+ * \internal
+ * This function calls __DriverAPIRec::UnbindContext, and then decrements
+ * __DRIdrawablePrivateRec::refcount which must be non-zero for a successful
+ * return.
+ * 
+ * While casting the opaque private pointers associated with the parameters
+ * into their respective real types it also assures they are not \c NULL. 
+ */
+static GLboolean driUnbindContext(__DRInativeDisplay *dpy, int scrn,
+			      __DRIid draw, __DRIid read,
+			      __DRIcontext *ctx)
+{
+    __DRIscreen *pDRIScreen;
+    __DRIdrawable *pdraw;
+    __DRIdrawable *pread;
+    __DRIcontextPrivate *pcp;
+    __DRIscreenPrivate *psp;
+    __DRIdrawablePrivate *pdp;
+    __DRIdrawablePrivate *prp;
+
+    /*
+    ** Assume error checking is done properly in glXMakeCurrent before
+    ** calling driUnbindContext.
+    */
+
+    if (ctx == NULL || draw == None || read == None) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
+    if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    psp = (__DRIscreenPrivate *)pDRIScreen->private;
+    pcp = (__DRIcontextPrivate *)ctx->private;
+
+    pdraw = __driFindDrawable(psp->drawHash, draw);
+    if (!pdraw) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+    pdp = (__DRIdrawablePrivate *)pdraw->private;
+
+    pread = __driFindDrawable(psp->drawHash, read);
+    if (!pread) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+    prp = (__DRIdrawablePrivate *)pread->private;
+
+
+    /* Let driver unbind drawable from context */
+    (*psp->DriverAPI.UnbindContext)(pcp);
+
+
+    if (pdp->refcount == 0) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    pdp->refcount--;
+
+    if (prp != pdp) {
+        if (prp->refcount == 0) {
+	    /* ERROR!!! */
+	    return GL_FALSE;
+	}
+
+	prp->refcount--;
+    }
+
+
+    /* XXX this is disabled so that if we call SwapBuffers on an unbound
+     * window we can determine the last context bound to the window and
+     * use that context's lock. (BrianP, 2-Dec-2000)
+     */
+#if 0
+    /* Unbind the drawable */
+    pcp->driDrawablePriv = NULL;
+    pdp->driContextPriv = &psp->dummyContextPriv;
+#endif
+
+    return GL_TRUE;
+}
+
+
+/**
+ * This function takes both a read buffer and a draw buffer.  This is needed
+ * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
+ * function.
+ * 
+ * \bug This function calls \c driCreateNewDrawable in two places with the
+ *      \c renderType hard-coded to \c GLX_WINDOW_BIT.  Some checking might
+ *      be needed in those places when support for pbuffers and / or pixmaps
+ *      is added.  Is it safe to assume that the drawable is a window?
+ */
+static GLboolean DoBindContext(__DRInativeDisplay *dpy,
+			  __DRIid draw, __DRIid read,
+			  __DRIcontext *ctx, const __GLcontextModes * modes,
+			  __DRIscreenPrivate *psp)
+{
+    __DRIdrawable *pdraw;
+    __DRIdrawablePrivate *pdp;
+    __DRIdrawable *pread;
+    __DRIdrawablePrivate *prp;
+    __DRIcontextPrivate * const pcp = ctx->private;
+
+
+    /* Find the _DRIdrawable which corresponds to the writing drawable. */
+    pdraw = __driFindDrawable(psp->drawHash, draw);
+    if (!pdraw) {
+	/* Allocate a new drawable */
+	pdraw = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
+	if (!pdraw) {
+	    /* ERROR!!! */
+	    return GL_FALSE;
+	}
+
+	/* Create a new drawable */
+	driCreateNewDrawable(dpy, modes, draw, pdraw, GLX_WINDOW_BIT,
+			     empty_attribute_list);
+	if (!pdraw->private) {
+	    /* ERROR!!! */
+	    _mesa_free(pdraw);
+	    return GL_FALSE;
+	}
+
+    }
+    pdp = (__DRIdrawablePrivate *) pdraw->private;
+
+    /* Find the _DRIdrawable which corresponds to the reading drawable. */
+    if (read == draw) {
+        /* read buffer == draw buffer */
+        prp = pdp;
+    }
+    else {
+        pread = __driFindDrawable(psp->drawHash, read);
+        if (!pread) {
+            /* Allocate a new drawable */
+            pread = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
+            if (!pread) {
+                /* ERROR!!! */
+                return GL_FALSE;
+            }
+
+            /* Create a new drawable */
+	    driCreateNewDrawable(dpy, modes, read, pread, GLX_WINDOW_BIT,
+				 empty_attribute_list);
+            if (!pread->private) {
+                /* ERROR!!! */
+                _mesa_free(pread);
+                return GL_FALSE;
+            }
+        }
+        prp = (__DRIdrawablePrivate *) pread->private;
+    }
+
+    /* Bind the drawable to the context */
+    pcp->driDrawablePriv = pdp;
+    pdp->driContextPriv = pcp;
+    pdp->refcount++;
+    if ( pdp != prp ) {
+	prp->refcount++;
+    }
+
+    /*
+    ** Now that we have a context associated with this drawable, we can
+    ** initialize the drawable information if has not been done before.
+    */
+    if (!pdp->pStamp || *pdp->pStamp != pdp->lastStamp) {
+	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+	__driUtilUpdateDrawableInfo(pdp);
+	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+    }
+
+    /* Call device-specific MakeCurrent */
+    (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
+
+    return GL_TRUE;
+}
+
+
+/**
+ * This function takes both a read buffer and a draw buffer.  This is needed
+ * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
+ * function.
+ */
+static GLboolean driBindContext(__DRInativeDisplay *dpy, int scrn,
+                            __DRIid draw, __DRIid read,
+                            __DRIcontext * ctx)
+{
+    __DRIscreen *pDRIScreen;
+
+    /*
+    ** Assume error checking is done properly in glXMakeCurrent before
+    ** calling driBindContext.
+    */
+
+    if (ctx == NULL || draw == None || read == None) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
+    if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    return DoBindContext( dpy, draw, read, ctx, ctx->mode,
+			  (__DRIscreenPrivate *)pDRIScreen->private );
+}
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Drawable handling functions                            */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Update private drawable information.
+ *
+ * \param pdp pointer to the private drawable information to update.
+ * 
+ * This function basically updates the __DRIdrawablePrivate struct's
+ * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
+ * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
+ * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If
+ * the values are different that means we have to update the clipping
+ * info.
+ */
+void
+__driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp)
+{
+    __DRIscreenPrivate *psp;
+    __DRIcontextPrivate *pcp = pdp->driContextPriv;
+    
+    if (!pcp || (pdp != pcp->driDrawablePriv)) {
+	/* ERROR!!! */
+	return;
+    }
+
+    psp = pdp->driScreenPriv;
+    if (!psp) {
+	/* ERROR!!! */
+	return;
+    }
+
+    if (pdp->pClipRects) {
+	_mesa_free(pdp->pClipRects); 
+    }
+
+    if (pdp->pBackClipRects) {
+	_mesa_free(pdp->pBackClipRects); 
+    }
+
+    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+
+    if (!__driFindDrawable(psp->drawHash, pdp->draw) ||
+	! (*dri_interface->getDrawableInfo)(pdp->display, pdp->screen, pdp->draw,
+			  &pdp->index, &pdp->lastStamp,
+			  &pdp->x, &pdp->y, &pdp->w, &pdp->h,
+			  &pdp->numClipRects, &pdp->pClipRects,
+			  &pdp->backX,
+			  &pdp->backY,
+			  &pdp->numBackClipRects,
+			  &pdp->pBackClipRects )) {
+	/* Error -- eg the window may have been destroyed.  Keep going
+	 * with no cliprects.
+	 */
+        pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */
+	pdp->numClipRects = 0;
+	pdp->pClipRects = NULL;
+	pdp->numBackClipRects = 0;
+	pdp->pBackClipRects = NULL;
+    }
+    else
+       pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
+
+    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+
+}
+
+/*@}*/
+
+/*****************************************************************/
+/** \name GLX callbacks                                          */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Swap buffers.
+ *
+ * \param dpy the display handle.
+ * \param drawablePrivate opaque pointer to the per-drawable private info.
+ * 
+ * \internal
+ * This function calls __DRIdrawablePrivate::swapBuffers.
+ * 
+ * Is called directly from glXSwapBuffers().
+ */
+static void driSwapBuffers( __DRInativeDisplay *dpy, void *drawablePrivate )
+{
+    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
+    dPriv->swapBuffers(dPriv);
+    (void) dpy;
+}
+
+/**
+ * Called directly from a number of higher-level GLX functions.
+ */
+static int driGetMSC( void *screenPrivate, int64_t *msc )
+{
+    __DRIscreenPrivate *sPriv = (__DRIscreenPrivate *) screenPrivate;
+
+    return sPriv->DriverAPI.GetMSC( sPriv, msc );
+}
+
+/**
+ * Called directly from a number of higher-level GLX functions.
+ */
+static int driGetSBC( __DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc )
+{
+   __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
+   __DRIswapInfo  sInfo;
+   int  status;
+
+
+   status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
+   *sbc = sInfo.swap_count;
+
+   return status;
+}
+
+static int driWaitForSBC( __DRInativeDisplay * dpy, void *drawablePriv,
+			  int64_t target_sbc,
+			  int64_t * msc, int64_t * sbc )
+{
+    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
+
+    return dPriv->driScreenPriv->DriverAPI.WaitForSBC( dPriv, target_sbc,
+                                                       msc, sbc );
+}
+
+static int driWaitForMSC( __DRInativeDisplay * dpy, void *drawablePriv,
+			  int64_t target_msc,
+			  int64_t divisor, int64_t remainder,
+			  int64_t * msc, int64_t * sbc )
+{
+    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
+    __DRIswapInfo  sInfo;
+    int  status;
+
+
+    status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
+                                                         divisor, remainder,
+                                                         msc );
+
+    /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync
+     * is supported but GLX_OML_sync_control is not.  Therefore, don't return
+     * an error value if GetSwapInfo() is not implemented.
+    */
+    if ( status == 0
+         && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {
+        status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
+        *sbc = sInfo.swap_count;
+    }
+
+    return status;
+}
+
+static int64_t driSwapBuffersMSC( __DRInativeDisplay * dpy, void *drawablePriv,
+				  int64_t target_msc,
+				  int64_t divisor, int64_t remainder )
+{
+    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
+
+    return dPriv->driScreenPriv->DriverAPI.SwapBuffersMSC( dPriv, target_msc,
+                                                           divisor, 
+                                                           remainder );
+}
+
+static void driCopySubBuffer( __DRInativeDisplay *dpy, void *drawablePrivate,
+			      int x, int y, int w, int h)
+{
+    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
+    dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
+    (void) dpy;
+}
+
+/**
+ * This is called via __DRIscreenRec's createNewDrawable pointer.
+ */
+static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
+				  const __GLcontextModes *modes,
+				  __DRIid draw,
+				  __DRIdrawable *pdraw,
+				  int renderType,
+				  const int *attrs)
+{
+    __DRIscreen * const pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
+    __DRIscreenPrivate *psp;
+    __DRIdrawablePrivate *pdp;
+
+
+    pdraw->private = NULL;
+
+    /* Since pbuffers are not yet supported, no drawable attributes are
+     * supported either.
+     */
+    (void) attrs;
+
+    if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
+	return NULL;
+    }
+
+    pdp = (__DRIdrawablePrivate *)_mesa_malloc(sizeof(__DRIdrawablePrivate));
+    if (!pdp) {
+	return NULL;
+    }
+
+    if (!(*dri_interface->createDrawable)(dpy, modes->screen, draw, &pdp->hHWDrawable)) {
+	_mesa_free(pdp);
+	return NULL;
+    }
+
+    pdp->draw = draw;
+    pdp->pdraw = pdraw;
+    pdp->refcount = 0;
+    pdp->pStamp = NULL;
+    pdp->lastStamp = 0;
+    pdp->index = 0;
+    pdp->x = 0;
+    pdp->y = 0;
+    pdp->w = 0;
+    pdp->h = 0;
+    pdp->numClipRects = 0;
+    pdp->numBackClipRects = 0;
+    pdp->pClipRects = NULL;
+    pdp->pBackClipRects = NULL;
+    pdp->display = dpy;
+    pdp->screen = modes->screen;
+
+    psp = (__DRIscreenPrivate *)pDRIScreen->private;
+    pdp->driScreenPriv = psp;
+    pdp->driContextPriv = &psp->dummyContextPriv;
+
+    if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, modes,
+					renderType == GLX_PIXMAP_BIT)) {
+       (void)(*dri_interface->destroyDrawable)(dpy, modes->screen, pdp->draw);
+       _mesa_free(pdp);
+       return NULL;
+    }
+
+    pdraw->private = pdp;
+    pdraw->destroyDrawable = driDestroyDrawable;
+    pdraw->swapBuffers = driSwapBuffers;  /* called by glXSwapBuffers() */
+
+    pdraw->getSBC = driGetSBC;
+    pdraw->waitForSBC = driWaitForSBC;
+    pdraw->waitForMSC = driWaitForMSC;
+    pdraw->swapBuffersMSC = driSwapBuffersMSC;
+    pdraw->frameTracking = NULL;
+    pdraw->queryFrameTracking = driQueryFrameTracking;
+
+    if (driCompareGLXAPIVersion (20060314) >= 0)
+	pdraw->copySubBuffer = driCopySubBuffer;
+
+    /* This special default value is replaced with the configured
+     * default value when the drawable is first bound to a direct
+     * rendering context. 
+     */
+    pdraw->swap_interval = (unsigned)-1;
+
+    pdp->swapBuffers = psp->DriverAPI.SwapBuffers;
+
+    /* Add pdraw to drawable list */
+    if (!__driAddDrawable(psp->drawHash, pdraw)) {
+	/* ERROR!!! */
+	(*pdraw->destroyDrawable)(dpy, pdp);
+	_mesa_free(pdp);
+	pdp = NULL;
+	pdraw->private = NULL;
+    }
+
+   return (void *) pdp;
+}
+
+static __DRIdrawable *
+driGetDrawable(__DRInativeDisplay *dpy, __DRIid draw, void *screenPrivate)
+{
+    __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
+
+    /*
+    ** Make sure this routine returns NULL if the drawable is not bound
+    ** to a direct rendering context!
+    */
+    return __driFindDrawable(psp->drawHash, draw);
+}
+
+static void
+driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate)
+{
+    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *) drawablePrivate;
+    __DRIscreenPrivate *psp;
+    int scrn;
+
+    if (pdp) {
+	psp = pdp->driScreenPriv;
+	scrn = psp->myNum;
+        (*psp->DriverAPI.DestroyBuffer)(pdp);
+	if ((*dri_interface->windowExists)(dpy, pdp->draw))
+	    (void)(*dri_interface->destroyDrawable)(dpy, scrn, pdp->draw);
+	drmHashDelete(psp->drawHash, pdp->draw);
+	if (pdp->pClipRects) {
+	    _mesa_free(pdp->pClipRects);
+	    pdp->pClipRects = NULL;
+	}
+	if (pdp->pBackClipRects) {
+	    _mesa_free(pdp->pBackClipRects);
+	    pdp->pBackClipRects = NULL;
+	}
+	_mesa_free(pdp);
+    }
+}
+
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Context handling functions                             */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Destroy the per-context private information.
+ * 
+ * \param dpy the display handle.
+ * \param scrn the screen number.
+ * \param contextPrivate opaque pointer to the per-drawable private info.
+ *
+ * \internal
+ * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
+ * drmDestroyContext(), and finally frees \p contextPrivate.
+ */
+static void
+driDestroyContext(__DRInativeDisplay *dpy, int scrn, void *contextPrivate)
+{
+    __DRIcontextPrivate  *pcp   = (__DRIcontextPrivate *) contextPrivate;
+
+    if (pcp) {
+	(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
+	__driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
+	(void) (*dri_interface->destroyContext)(dpy, scrn, pcp->contextID);
+	_mesa_free(pcp);
+    }
+}
+
+
+/**
+ * Create the per-drawable private driver information.
+ * 
+ * \param dpy           The display handle.
+ * \param modes         Mode used to create the new context.
+ * \param render_type   Type of rendering target.  \c GLX_RGBA is the only
+ *                      type likely to ever be supported for direct-rendering.
+ * \param sharedPrivate The shared context dependent methods or \c NULL if
+ *                      non-existent.
+ * \param pctx          DRI context to receive the context dependent methods.
+ *
+ * \returns An opaque pointer to the per-context private information on
+ *          success, or \c NULL on failure.
+ * 
+ * \internal
+ * This function allocates and fills a __DRIcontextPrivateRec structure.  It
+ * performs some device independent initialization and passes all the
+ * relevent information to __DriverAPIRec::CreateContext to create the
+ * context.
+ *
+ */
+static void *
+driCreateNewContext(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
+		    int render_type, void *sharedPrivate, __DRIcontext *pctx)
+{
+    __DRIscreen *pDRIScreen;
+    __DRIcontextPrivate *pcp;
+    __DRIcontextPrivate *pshare = (__DRIcontextPrivate *) sharedPrivate;
+    __DRIscreenPrivate *psp;
+    void * const shareCtx = (pshare != NULL) ? pshare->driverPrivate : NULL;
+
+    pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
+    if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
+	/* ERROR!!! */
+	return NULL;
+    } 
+
+    psp = (__DRIscreenPrivate *)pDRIScreen->private;
+
+    pcp = (__DRIcontextPrivate *)_mesa_malloc(sizeof(__DRIcontextPrivate));
+    if (!pcp) {
+	return NULL;
+    }
+
+    if (! (*dri_interface->createContext)(dpy, modes->screen, modes->fbconfigID,
+					&pcp->contextID, &pcp->hHWContext)) {
+	_mesa_free(pcp);
+	return NULL;
+    }
+
+    pcp->display = dpy;
+    pcp->driScreenPriv = psp;
+    pcp->driDrawablePriv = NULL;
+
+    /* When the first context is created for a screen, initialize a "dummy"
+     * context.
+     */
+
+    if (!psp->dummyContextPriv.driScreenPriv) {
+        psp->dummyContextPriv.contextID = 0;
+        psp->dummyContextPriv.hHWContext = psp->pSAREA->dummy_context;
+        psp->dummyContextPriv.driScreenPriv = psp;
+        psp->dummyContextPriv.driDrawablePriv = NULL;
+        psp->dummyContextPriv.driverPrivate = NULL;
+	/* No other fields should be used! */
+    }
+
+    pctx->destroyContext = driDestroyContext;
+    pctx->bindContext    = driBindContext;
+    pctx->unbindContext  = driUnbindContext;
+
+    if ( !(*psp->DriverAPI.CreateContext)(modes, pcp, shareCtx) ) {
+        (void) (*dri_interface->destroyContext)(dpy, modes->screen,
+						pcp->contextID);
+        _mesa_free(pcp);
+        return NULL;
+    }
+
+    __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
+
+    return pcp;
+}
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Screen handling functions                              */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Destroy the per-screen private information.
+ * 
+ * \param dpy the display handle.
+ * \param scrn the screen number.
+ * \param screenPrivate opaque pointer to the per-screen private information.
+ *
+ * \internal
+ * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
+ * drmClose(), and finally frees \p screenPrivate.
+ */
+static void driDestroyScreen(__DRInativeDisplay *dpy, int scrn, void *screenPrivate)
+{
+    __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
+
+    if (psp) {
+	/* No interaction with the X-server is possible at this point.  This
+	 * routine is called after XCloseDisplay, so there is no protocol
+	 * stream open to the X-server anymore.
+	 */
+
+	if (psp->DriverAPI.DestroyScreen)
+	    (*psp->DriverAPI.DestroyScreen)(psp);
+
+	(void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	(void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	_mesa_free(psp->pDevPriv);
+	(void)drmClose(psp->fd);
+	if ( psp->modes != NULL ) {
+	    (*dri_interface->destroyContextModes)( psp->modes );
+	}
+
+	assert(psp->drawHash);
+	drmHashDestroy(psp->drawHash);
+
+	_mesa_free(psp);
+    }
+}
+
+
+/**
+ * Utility function used to create a new driver-private screen structure.
+ * 
+ * \param dpy   Display pointer
+ * \param scrn  Index of the screen
+ * \param psc   DRI screen data (not driver private)
+ * \param modes Linked list of known display modes.  This list is, at a
+ *              minimum, a list of modes based on the current display mode.
+ *              These roughly match the set of available X11 visuals, but it
+ *              need not be limited to X11!  The calling libGL should create
+ *              a list that will inform the driver of the current display
+ *              mode (i.e., color buffer depth, depth buffer depth, etc.).
+ * \param ddx_version Version of the 2D DDX.  This may not be meaningful for
+ *                    all drivers.
+ * \param dri_version Version of the "server-side" DRI.
+ * \param drm_version Version of the kernel DRM.
+ * \param frame_buffer Data describing the location and layout of the
+ *                     framebuffer.
+ * \param pSAREA       Pointer the the SAREA.
+ * \param fd           Device handle for the DRM.
+ * \param internal_api_version  Version of the internal interface between the
+ *                              driver and libGL.
+ * \param driverAPI Driver API functions used by other routines in dri_util.c.
+ * 
+ * \note
+ * There is no need to check the minimum API version in this function.  Since
+ * the \c __driCreateNewScreen function is versioned, it is impossible for a
+ * loader that is too old to even load this driver.
+ */
+__DRIscreenPrivate *
+__driUtilCreateNewScreen(__DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+			 __GLcontextModes * modes,
+			 const __DRIversion * ddx_version,
+			 const __DRIversion * dri_version,
+			 const __DRIversion * drm_version,
+			 const __DRIframebuffer * frame_buffer,
+			 drm_sarea_t *pSAREA,
+			 int fd,
+			 int internal_api_version,
+			 const struct __DriverAPIRec *driverAPI)
+{
+    __DRIscreenPrivate *psp;
+
+
+    api_ver = internal_api_version;
+
+    psp = (__DRIscreenPrivate *)_mesa_malloc(sizeof(__DRIscreenPrivate));
+    if (!psp) {
+	return NULL;
+    }
+
+    /* Create the hash table */
+    psp->drawHash = drmHashCreate();
+    if ( psp->drawHash == NULL ) {
+	_mesa_free( psp );
+	return NULL;
+    }
+
+    psp->display = dpy;
+    psp->myNum = scrn;
+    psp->psc = psc;
+    psp->modes = modes;
+
+    /*
+    ** NOT_DONE: This is used by the X server to detect when the client
+    ** has died while holding the drawable lock.  The client sets the
+    ** drawable lock to this value.
+    */
+    psp->drawLockID = 1;
+
+    psp->drmMajor = drm_version->major;
+    psp->drmMinor = drm_version->minor;
+    psp->drmPatch = drm_version->patch;
+    psp->ddxMajor = ddx_version->major;
+    psp->ddxMinor = ddx_version->minor;
+    psp->ddxPatch = ddx_version->patch;
+    psp->driMajor = dri_version->major;
+    psp->driMinor = dri_version->minor;
+    psp->driPatch = dri_version->patch;
+
+    /* install driver's callback functions */
+    memcpy( &psp->DriverAPI, driverAPI, sizeof(struct __DriverAPIRec) );
+
+    psp->pSAREA = pSAREA;
+
+    psp->pFB = frame_buffer->base;
+    psp->fbSize = frame_buffer->size;
+    psp->fbStride = frame_buffer->stride;
+    psp->fbWidth = frame_buffer->width;
+    psp->fbHeight = frame_buffer->height;
+    psp->devPrivSize = frame_buffer->dev_priv_size;
+    psp->pDevPriv = frame_buffer->dev_priv;
+    psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
+
+    psp->fd = fd;
+
+    /*
+    ** Do not init dummy context here; actual initialization will be
+    ** done when the first DRI context is created.  Init screen priv ptr
+    ** to NULL to let CreateContext routine that it needs to be inited.
+    */
+    psp->dummyContextPriv.driScreenPriv = NULL;
+
+    psc->destroyScreen     = driDestroyScreen;
+    psc->createNewDrawable = driCreateNewDrawable;
+    psc->getDrawable       = driGetDrawable;
+    psc->getMSC            = driGetMSC;
+    psc->createNewContext  = driCreateNewContext;
+
+    if ( (psp->DriverAPI.InitDriver != NULL)
+	 && !(*psp->DriverAPI.InitDriver)(psp) ) {
+	_mesa_free( psp );
+	return NULL;
+    }
+
+
+    return psp;
+}
+
+
+/**
+ * Compare the current GLX API version with a driver supplied required version.
+ * 
+ * The minimum required version is compared with the API version exported by
+ * the \c __glXGetInternalVersion function (in libGL.so).
+ * 
+ * \param   required_version Minimum required internal GLX API version.
+ * \return  A tri-value return, as from strcmp is returned.  A value less
+ *          than, equal to, or greater than zero will be returned if the
+ *          internal GLX API version is less than, equal to, or greater
+ *          than \c required_version.
+ *
+ * \sa __glXGetInternalVersion().
+ */
+int driCompareGLXAPIVersion( GLint required_version )
+{
+   if ( api_ver > required_version ) {
+      return 1;
+   }
+   else if ( api_ver == required_version ) {
+      return 0;
+   }
+
+   return -1;
+}
+
+
+static int
+driQueryFrameTracking( __DRInativeDisplay * dpy, void * priv,
+		       int64_t * sbc, int64_t * missedFrames,
+		       float * lastMissedUsage, float * usage )
+{
+   __DRIswapInfo   sInfo;
+   int             status;
+   int64_t         ust;
+   __DRIdrawablePrivate * dpriv = (__DRIdrawablePrivate *) priv;
+
+
+   status = dpriv->driScreenPriv->DriverAPI.GetSwapInfo( dpriv, & sInfo );
+   if ( status == 0 ) {
+      *sbc = sInfo.swap_count;
+      *missedFrames = sInfo.swap_missed_count;
+      *lastMissedUsage = sInfo.swap_missed_usage;
+
+      (*dri_interface->getUST)( & ust );
+      *usage = driCalculateSwapUsage( dpriv, sInfo.swap_ust, ust );
+   }
+
+   return status;
+}
+
+
+/**
+ * Calculate amount of swap interval used between GLX buffer swaps.
+ * 
+ * The usage value, on the range [0,max], is the fraction of total swap
+ * interval time used between GLX buffer swaps is calculated.
+ *
+ *            \f$p = t_d / (i * t_r)\f$
+ * 
+ * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the
+ * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time
+ * required for a single vertical refresh period (as returned by \c
+ * glXGetMscRateOML).
+ * 
+ * See the documentation for the GLX_MESA_swap_frame_usage extension for more
+ * details.
+ *
+ * \param   dPriv  Pointer to the private drawable structure.
+ * \return  If less than a single swap interval time period was required
+ *          between GLX buffer swaps, a number greater than 0 and less than
+ *          1.0 is returned.  If exactly one swap interval time period is
+ *          required, 1.0 is returned, and if more than one is required then
+ *          a number greater than 1.0 will be returned.
+ *
+ * \sa glXSwapIntervalSGI glXGetMscRateOML
+ * 
+ * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it
+ *       be possible to cache the sync rate?
+ */
+float
+driCalculateSwapUsage( __DRIdrawablePrivate *dPriv, int64_t last_swap_ust,
+		       int64_t current_ust )
+{
+   int32_t   n;
+   int32_t   d;
+   int       interval;
+   float     usage = 1.0;
+
+
+   if ( (*dri_interface->getMSCRate)( dPriv->display, dPriv->draw, &n, &d ) ) {
+      interval = (dPriv->pdraw->swap_interval != 0)
+	  ? dPriv->pdraw->swap_interval : 1;
+
+
+      /* We want to calculate
+       * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get
+       * current_UST by calling __glXGetUST.  last_swap_UST is stored in
+       * dPriv->swap_ust.  interval has already been calculated.
+       *
+       * The only tricky part is us_per_refresh.  us_per_refresh is
+       * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it
+       * around and say us_per_refresh = 1000000 * d / n.  Since this goes in
+       * the denominator of the final calculation, we calculate
+       * (interval * 1000000 * d) and move n into the numerator.
+       */
+
+      usage = (current_ust - last_swap_ust);
+      usage *= n;
+      usage /= (interval * d);
+      usage /= 1000000.0;
+   }
+   
+   return usage;
+}
+
+/*@}*/
diff --git a/src/mesa/drivers/dri/common/dri_util.h b/src/mesa/drivers/dri/common/dri_util.h
new file mode 100644
index 0000000..14c24a0
--- /dev/null
+++ b/src/mesa/drivers/dri/common/dri_util.h
@@ -0,0 +1,557 @@
+/* $XFree86: xc/lib/GL/dri/dri_util.h,v 1.1 2002/02/22 21:32:52 dawes Exp $ */
+/**
+ * \file dri_util.h
+ * DRI utility functions definitions.
+ *
+ * This module acts as glue between GLX and the actual hardware driver.  A DRI
+ * driver doesn't really \e have to use any of this - it's optional.  But, some
+ * useful stuff is done here that otherwise would have to be duplicated in most
+ * drivers.
+ * 
+ * Basically, these utility functions take care of some of the dirty details of
+ * screen initialization, context creation, context binding, DRM setup, etc.
+ *
+ * These functions are compiled into each DRI driver so libGL.so knows nothing
+ * about them.
+ *
+ * \sa dri_util.c.
+ * 
+ * \author Kevin E. Martin <kevin@precisioninsight.com>
+ * \author Brian Paul <brian@precisioninsight.com>
+ */
+
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * 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 PRECISION INSIGHT AND/OR ITS 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.
+ */
+
+
+#ifndef _DRI_UTIL_H_
+#define _DRI_UTIL_H_
+
+#define CAPI  /* XXX this should be globally defined somewhere */
+
+#include <GL/gl.h>
+#include "drm.h"
+#include "drm_sarea.h"
+#include "xf86drm.h"
+#include "GL/internal/glcore.h"
+#include "GL/internal/dri_interface.h"
+
+#define GLX_BAD_CONTEXT                    5
+
+typedef struct __DRIdisplayPrivateRec  __DRIdisplayPrivate;
+typedef struct __DRIscreenPrivateRec   __DRIscreenPrivate;
+typedef struct __DRIcontextPrivateRec  __DRIcontextPrivate;
+typedef struct __DRIdrawablePrivateRec __DRIdrawablePrivate;
+typedef struct __DRIswapInfoRec        __DRIswapInfo;
+typedef struct __DRIutilversionRec2    __DRIutilversion2;
+
+
+/**
+ * Used by DRI_VALIDATE_DRAWABLE_INFO
+ */
+#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv)              \
+    do {                                                        \
+	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {     \
+	    __driUtilUpdateDrawableInfo(pDrawPriv);             \
+	}                                                       \
+    } while (0)
+
+
+/**
+ * Utility macro to validate the drawable information.
+ *
+ * See __DRIdrawablePrivate::pStamp and __DRIdrawablePrivate::lastStamp.
+ */
+#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp)                            \
+do {                                                                    \
+    while (*(pdp->pStamp) != pdp->lastStamp) {                          \
+	DRM_UNLOCK(psp->fd, &psp->pSAREA->lock,                         \
+		   pdp->driContextPriv->hHWContext);                    \
+                                                                        \
+	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);     \
+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \
+	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);   \
+                                                                        \
+	DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock,                     \
+		       pdp->driContextPriv->hHWContext);                \
+    }                                                                   \
+} while (0)
+
+
+/**
+ * Driver callback functions.
+ *
+ * Each DRI driver must have one of these structures with all the pointers set
+ * to appropriate functions within the driver.
+ * 
+ * When glXCreateContext() is called, for example, it'll call a helper function
+ * dri_util.c which in turn will jump through the \a CreateContext pointer in
+ * this structure.
+ */
+struct __DriverAPIRec {
+    /** 
+     * Driver initialization callback
+     */
+    GLboolean (*InitDriver)(__DRIscreenPrivate *driScrnPriv);
+    
+    /**
+     * Screen destruction callback
+     */
+    void (*DestroyScreen)(__DRIscreenPrivate *driScrnPriv);
+
+    /**
+     * Context creation callback
+     */	    	    
+    GLboolean (*CreateContext)(const __GLcontextModes *glVis,
+                               __DRIcontextPrivate *driContextPriv,
+                               void *sharedContextPrivate);
+
+    /**
+     * Context destruction callback
+     */
+    void (*DestroyContext)(__DRIcontextPrivate *driContextPriv);
+
+    /**
+     * Buffer (drawable) creation callback
+     */
+    GLboolean (*CreateBuffer)(__DRIscreenPrivate *driScrnPriv,
+                              __DRIdrawablePrivate *driDrawPriv,
+                              const __GLcontextModes *glVis,
+                              GLboolean pixmapBuffer);
+    
+    /**
+     * Buffer (drawable) destruction callback
+     */
+    void (*DestroyBuffer)(__DRIdrawablePrivate *driDrawPriv);
+
+    /**
+     * Buffer swapping callback 
+     */
+    void (*SwapBuffers)(__DRIdrawablePrivate *driDrawPriv);
+
+    /**
+     * Context activation callback
+     */
+    GLboolean (*MakeCurrent)(__DRIcontextPrivate *driContextPriv,
+                             __DRIdrawablePrivate *driDrawPriv,
+                             __DRIdrawablePrivate *driReadPriv);
+
+    /**
+     * Context unbinding callback
+     */
+    GLboolean (*UnbindContext)(__DRIcontextPrivate *driContextPriv);
+  
+    /**
+     * Retrieves statistics about buffer swap operations.  Required if
+     * GLX_OML_sync_control or GLX_MESA_swap_frame_usage is supported.
+     */
+    int (*GetSwapInfo)( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
+
+
+    /**
+     * Required if GLX_SGI_video_sync or GLX_OML_sync_control is
+     * supported.
+     */
+    int (*GetMSC)( __DRIscreenPrivate * priv, int64_t * count );
+
+    /**
+     * These are required if GLX_OML_sync_control is supported.
+     */
+    /*@{*/
+    int (*WaitForMSC)( __DRIdrawablePrivate *priv, int64_t target_msc, 
+		       int64_t divisor, int64_t remainder,
+		       int64_t * msc );
+    int (*WaitForSBC)( __DRIdrawablePrivate *priv, int64_t target_sbc,
+		       int64_t * msc, int64_t * sbc );
+
+    int64_t (*SwapBuffersMSC)( __DRIdrawablePrivate *priv, int64_t target_msc,
+			       int64_t divisor, int64_t remainder );
+    /*@}*/
+    void (*CopySubBuffer)(__DRIdrawablePrivate *driDrawPriv,
+			  int x, int y, int w, int h);
+};
+
+
+struct __DRIswapInfoRec {
+    /** 
+     * Number of swapBuffers operations that have been *completed*. 
+     */
+    u_int64_t swap_count;
+
+    /**
+     * Unadjusted system time of the last buffer swap.  This is the time
+     * when the swap completed, not the time when swapBuffers was called.
+     */
+    int64_t   swap_ust;
+
+    /**
+     * Number of swap operations that occurred after the swap deadline.  That
+     * is if a swap happens more than swap_interval frames after the previous
+     * swap, it has missed its deadline.  If swap_interval is 0, then the
+     * swap deadline is 1 frame after the previous swap.
+     */
+    u_int64_t swap_missed_count;
+
+    /**
+     * Amount of time used by the last swap that missed its deadline.  This
+     * is calculated as (__glXGetUST() - swap_ust) / (swap_interval * 
+     * time_for_single_vrefresh)).  If the actual value of swap_interval is
+     * 0, then 1 is used instead.  If swap_missed_count is non-zero, this
+     * should be greater-than 1.0.
+     */
+    float     swap_missed_usage;
+};
+
+
+/**
+ * Per-drawable private DRI driver information.
+ */
+struct __DRIdrawablePrivateRec {
+    /**
+     * Kernel drawable handle
+     */
+    drm_drawable_t hHWDrawable;
+
+    /**
+     * Driver's private drawable information.  
+     *
+     * This structure is opaque.
+     */
+    void *driverPrivate;
+
+    /**
+     * X's drawable ID associated with this private drawable.
+     */
+    __DRIid draw;
+    __DRIdrawable *pdraw;
+
+    /**
+     * Reference count for number of context's currently bound to this
+     * drawable.  
+     *
+     * Once it reaches zero, the drawable can be destroyed.
+     *
+     * \note This behavior will change with GLX 1.3.
+     */
+    int refcount;
+
+    /**
+     * Index of this drawable information in the SAREA.
+     */
+    unsigned int index;
+
+    /**
+     * Pointer to the "drawable has changed ID" stamp in the SAREA.
+     */
+    unsigned int *pStamp;
+
+    /**
+     * Last value of the stamp.
+     *
+     * If this differs from the value stored at __DRIdrawablePrivate::pStamp,
+     * then the drawable information has been modified by the X server, and the
+     * drawable information (below) should be retrieved from the X server.
+     */
+    unsigned int lastStamp;
+
+    /**
+     * \name Drawable 
+     *
+     * Drawable information used in software fallbacks.
+     */
+    /*@{*/
+    int x;
+    int y;
+    int w;
+    int h;
+    int numClipRects;
+    drm_clip_rect_t *pClipRects;
+    /*@}*/
+
+    /**
+     * \name Back and depthbuffer
+     *
+     * Information about the back and depthbuffer where different from above.
+     */
+    /*@{*/
+    int backX;
+    int backY;
+    int backClipRectType;
+    int numBackClipRects;
+    drm_clip_rect_t *pBackClipRects;
+    /*@}*/
+
+    /**
+     * Pointer to context to which this drawable is currently bound.
+     */
+    __DRIcontextPrivate *driContextPriv;
+
+    /**
+     * Pointer to screen on which this drawable was created.
+     */
+    __DRIscreenPrivate *driScreenPriv;
+
+    /**
+     * \name Display and screen information.
+     * 
+     * Basically just need these for when the locking code needs to call
+     * \c __driUtilUpdateDrawableInfo.
+     */
+    /*@{*/
+    __DRInativeDisplay *display;
+    int screen;
+    /*@}*/
+
+    /**
+     * Called via glXSwapBuffers().
+     */
+    void (*swapBuffers)( __DRIdrawablePrivate *dPriv );
+};
+
+/**
+ * Per-context private driver information.
+ */
+struct __DRIcontextPrivateRec {
+    /**
+     * Kernel context handle used to access the device lock.
+     */
+    __DRIid contextID;
+
+    /**
+     * Kernel context handle used to access the device lock.
+     */
+    drm_context_t hHWContext;
+
+    /**
+     * Device driver's private context data.  This structure is opaque.
+     */
+    void *driverPrivate;
+
+    /**
+     * This context's display pointer.
+     */
+    __DRInativeDisplay *display;
+
+    /**
+     * Pointer to drawable currently bound to this context.
+     */
+    __DRIdrawablePrivate *driDrawablePriv;
+
+    /**
+     * Pointer to screen on which this context was created.
+     */
+    __DRIscreenPrivate *driScreenPriv;
+};
+
+/**
+ * Per-screen private driver information.
+ */
+struct __DRIscreenPrivateRec {
+    /**
+     * Display for this screen
+     */
+    __DRInativeDisplay *display;
+
+    /**
+     * Current screen's number
+     */
+    int myNum;
+
+    /**
+     * Callback functions into the hardware-specific DRI driver code.
+     */
+    struct __DriverAPIRec DriverAPI;
+
+    /**
+     * \name DDX version
+     * DDX / 2D driver version information.
+     * \todo Replace these fields with a \c __DRIversionRec.
+     */
+    /*@{*/
+    int ddxMajor;
+    int ddxMinor;
+    int ddxPatch;
+    /*@}*/
+
+    /**
+     * \name DRI version
+     * DRI X extension version information.
+     * \todo Replace these fields with a \c __DRIversionRec.
+     */
+    /*@{*/
+    int driMajor;
+    int driMinor;
+    int driPatch;
+    /*@}*/
+
+    /**
+     * \name DRM version
+     * DRM (kernel module) version information.
+     * \todo Replace these fields with a \c __DRIversionRec.
+     */
+    /*@{*/
+    int drmMajor;
+    int drmMinor;
+    int drmPatch;
+    /*@}*/
+
+    /**
+     * ID used when the client sets the drawable lock.
+     *
+     * The X server uses this value to detect if the client has died while
+     * holding the drawable lock.
+     */
+    int drawLockID;
+
+    /**
+     * File descriptor returned when the kernel device driver is opened.
+     * 
+     * Used to:
+     *   - authenticate client to kernel
+     *   - map the frame buffer, SAREA, etc.
+     *   - close the kernel device driver
+     */
+    int fd;
+
+    /**
+     * SAREA pointer 
+     *
+     * Used to access:
+     *   - the device lock
+     *   - the device-independent per-drawable and per-context(?) information
+     */
+    drm_sarea_t *pSAREA;
+
+    /**
+     * \name Direct frame buffer access information 
+     * Used for software fallbacks.
+     */
+    /*@{*/
+    unsigned char *pFB;
+    int fbSize;
+    int fbOrigin;
+    int fbStride;
+    int fbWidth;
+    int fbHeight;
+    int fbBPP;
+    /*@}*/
+
+    /**
+     * \name Device-dependent private information (stored in the SAREA).
+     *
+     * This data is accessed by the client driver only.
+     */
+    /*@{*/
+    void *pDevPriv;
+    int devPrivSize;
+    /*@}*/
+
+    /**
+     * Dummy context to which drawables are bound when not bound to any
+     * other context. 
+     *
+     * A dummy hHWContext is created for this context, and is used by the GL
+     * core when a hardware lock is required but the drawable is not currently
+     * bound (e.g., potentially during a SwapBuffers request).  The dummy
+     * context is created when the first "real" context is created on this
+     * screen.
+     */
+    __DRIcontextPrivate dummyContextPriv;
+
+    /**
+     * Hash table to hold the drawable information for this screen.
+     */
+    void *drawHash;
+
+    /**
+     * Device-dependent private information (not stored in the SAREA).
+     * 
+     * This pointer is never touched by the DRI layer.
+     */
+    void *private;
+
+    /**
+     * GLX visuals / FBConfigs for this screen.  These are stored as a
+     * linked list.
+     * 
+     * \note
+     * This field is \b only used in conjunction with the old interfaces.  If
+     * the new interfaces are used, this field will be set to \c NULL and will
+     * not be dereferenced.
+     */
+    __GLcontextModes *modes;
+
+    /**
+     * Pointer back to the \c __DRIscreen that contains this structure.
+     */
+
+    __DRIscreen *psc;
+};
+
+
+/**
+ * Used to store a version which includes a major range instead of a single
+ * major version number.
+ */
+struct __DRIutilversionRec2 {
+    int    major_min;    /** min allowed Major version number. */
+    int    major_max;    /** max allowed Major version number. */
+    int    minor;        /**< Minor version number. */
+    int    patch;        /**< Patch-level. */
+};
+
+
+extern void
+__driUtilMessage(const char *f, ...);
+
+
+extern void
+__driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp);
+
+
+extern __DRIscreenPrivate * __driUtilCreateNewScreen( __DRInativeDisplay *dpy,
+    int scrn, __DRIscreen *psc, __GLcontextModes * modes,
+    const __DRIversion * ddx_version, const __DRIversion * dri_version,
+    const __DRIversion * drm_version, const __DRIframebuffer * frame_buffer,
+    drm_sarea_t *pSAREA, int fd, int internal_api_version,
+    const struct __DriverAPIRec *driverAPI );
+
+/* Test the version of the internal GLX API.  Returns a value like strcmp. */
+extern int
+driCompareGLXAPIVersion( GLint required_version );
+
+extern float
+driCalculateSwapUsage( __DRIdrawablePrivate *dPriv,
+		       int64_t last_swap_ust, int64_t current_ust );
+
+/**
+ * Pointer to the \c __DRIinterfaceMethods passed to the driver by the loader.
+ * 
+ * This pointer is set in the driver's \c __driCreateNewScreen function and
+ * is defined in dri_util.c.
+ */
+extern const __DRIinterfaceMethods * dri_interface;
+
+#endif /* _DRI_UTIL_H_ */
diff --git a/src/mesa/drivers/dri/common/drirenderbuffer.c b/src/mesa/drivers/dri/common/drirenderbuffer.c
new file mode 100644
index 0000000..2e47781
--- /dev/null
+++ b/src/mesa/drivers/dri/common/drirenderbuffer.c
@@ -0,0 +1,215 @@
+
+#include "mtypes.h"
+#include "drirenderbuffer.h"
+#include "framebuffer.h"
+#include "renderbuffer.h"
+#include "imports.h"
+
+
+/**
+ * This will get called when a window (gl_framebuffer) is resized (probably
+ * via driUpdateFramebufferSize(), below).
+ * Just update width, height and internal format fields for now.
+ * There's usually no memory allocation above because the present
+ * DRI drivers use statically-allocated full-screen buffers. If that's not
+ * the case for a DRI driver, a different AllocStorage method should
+ * be used.
+ */
+static GLboolean
+driRenderbufferStorage(GLcontext *ctx, struct gl_renderbuffer *rb,
+                       GLenum internalFormat, GLuint width, GLuint height)
+{
+   rb->Width = width;
+   rb->Height = height;
+   rb->InternalFormat = internalFormat;
+   return GL_TRUE;
+}
+
+
+static void
+driDeleteRenderbuffer(struct gl_renderbuffer *rb)
+{
+   /* don't free rb->Data  Chances are it's a memory mapped region for
+    * the dri drivers.
+    */
+   _mesa_free(rb);
+}
+
+
+/**
+ * Allocate a new driRenderbuffer object.
+ * Individual drivers are free to implement different versions of
+ * this function.
+ *
+ * At this time, this function can only be used for window-system
+ * renderbuffers, not user-created RBOs.
+ *
+ * \param format  Either GL_RGBA, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24,
+ *                GL_DEPTH_COMPONENT32, or GL_STENCIL_INDEX8_EXT (for now).
+ * \param addr  address in main memory of the buffer.  Probably a memory
+ *              mapped region.
+ * \param cpp  chars or bytes per pixel
+ * \param offset  start of renderbuffer with respect to start of framebuffer
+ * \param pitch   pixels per row
+ */
+driRenderbuffer *
+driNewRenderbuffer(GLenum format, GLvoid *addr,
+                   GLint cpp, GLint offset, GLint pitch,
+                   __DRIdrawablePrivate *dPriv)
+{
+   driRenderbuffer *drb;
+
+   assert(format == GL_RGBA ||
+          format == GL_RGB5 ||
+          format == GL_RGBA8 ||
+          format == GL_DEPTH_COMPONENT16 ||
+          format == GL_DEPTH_COMPONENT24 ||
+          format == GL_DEPTH_COMPONENT32 ||
+          format == GL_STENCIL_INDEX8_EXT);
+
+   assert(cpp > 0);
+   assert(pitch > 0);
+
+   drb = _mesa_calloc(sizeof(driRenderbuffer));
+   if (drb) {
+      const GLuint name = 0;
+
+      _mesa_init_renderbuffer(&drb->Base, name);
+
+      /* Make sure we're using a null-valued GetPointer routine */
+      assert(drb->Base.GetPointer(NULL, &drb->Base, 0, 0) == NULL);
+
+      drb->Base.InternalFormat = format;
+
+      if (format == GL_RGBA || format == GL_RGB5 || format == GL_RGBA8) {
+         /* Color */
+         drb->Base._BaseFormat = GL_RGBA;
+         drb->Base.DataType = GL_UNSIGNED_BYTE;
+         if (format == GL_RGB5) {
+            drb->Base.RedBits = 5;
+            drb->Base.GreenBits = 6;
+            drb->Base.BlueBits = 5;
+         }
+         else {
+            drb->Base.RedBits =
+            drb->Base.GreenBits =
+            drb->Base.BlueBits =
+            drb->Base.AlphaBits = 8;
+         }
+      }
+      else if (format == GL_DEPTH_COMPONENT16) {
+         /* Depth */
+         drb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+         /* we always Get/Put 32-bit Z values */
+         drb->Base.DataType = GL_UNSIGNED_INT;
+         drb->Base.DepthBits = 16;
+      }
+      else if (format == GL_DEPTH_COMPONENT24) {
+         /* Depth */
+         drb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+         /* we always Get/Put 32-bit Z values */
+         drb->Base.DataType = GL_UNSIGNED_INT;
+         drb->Base.DepthBits = 24;
+      }
+      else if (format == GL_DEPTH_COMPONENT32) {
+         /* Depth */
+         drb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+         /* we always Get/Put 32-bit Z values */
+         drb->Base.DataType = GL_UNSIGNED_INT;
+         drb->Base.DepthBits = 32;
+      }
+      else {
+         /* Stencil */
+         ASSERT(format == GL_STENCIL_INDEX8_EXT);
+         drb->Base._BaseFormat = GL_STENCIL_INDEX;
+         drb->Base.DataType = GL_UNSIGNED_BYTE;
+         drb->Base.StencilBits = 8;
+      }
+
+      /* XXX if we were allocating a user-created renderbuffer, we'd have
+       * to fill in the Red/Green/Blue/.../Bits values too.
+       */
+
+      drb->Base.AllocStorage = driRenderbufferStorage;
+      drb->Base.Delete = driDeleteRenderbuffer;
+
+      drb->Base.Data = addr;
+
+      /* DRI renderbuffer-specific fields: */
+      drb->dPriv = dPriv;
+      drb->offset = offset;
+      drb->pitch = pitch;
+      drb->cpp = cpp;
+
+      /* may be changed if page flipping is active: */
+      drb->flippedOffset = offset;
+      drb->flippedPitch = pitch;
+      drb->flippedData = addr;
+   }
+   return drb;
+}
+
+
+/**
+ * Update the front and back renderbuffers' flippedPitch/Offset/Data fields.
+ * If stereo, flip both the left and right pairs.
+ * This is used when we do double buffering via page flipping.
+ * \param fb  the framebuffer we're page flipping
+ * \param flipped  if true, set flipped values, else set non-flipped values
+ */
+void
+driFlipRenderbuffers(struct gl_framebuffer *fb, GLboolean flipped)
+{
+   const GLuint count = fb->Visual.stereoMode ? 2 : 1;
+   GLuint lr; /* left or right */
+
+   /* we shouldn't really call this function if single-buffered, but
+    * play it safe.
+    */
+   if (!fb->Visual.doubleBufferMode)
+      return;
+
+   for (lr = 0; lr < count; lr++) {
+      GLuint frontBuf = (lr == 0) ? BUFFER_FRONT_LEFT : BUFFER_FRONT_RIGHT;
+      GLuint backBuf  = (lr == 0) ? BUFFER_BACK_LEFT  : BUFFER_BACK_RIGHT;
+      driRenderbuffer *front_drb
+         = (driRenderbuffer *) fb->Attachment[frontBuf].Renderbuffer;
+      driRenderbuffer *back_drb
+         = (driRenderbuffer *) fb->Attachment[backBuf].Renderbuffer;
+
+      if (flipped) {
+         front_drb->flippedOffset = back_drb->offset;
+         front_drb->flippedPitch  = back_drb->pitch;
+         front_drb->flippedData   = back_drb->Base.Data;
+         back_drb->flippedOffset  = front_drb->offset;
+         back_drb->flippedPitch   = front_drb->pitch;
+         back_drb->flippedData    = front_drb->Base.Data;
+      }
+      else {
+         front_drb->flippedOffset = front_drb->offset;
+         front_drb->flippedPitch  = front_drb->pitch;
+         front_drb->flippedData   = front_drb->Base.Data;
+         back_drb->flippedOffset  = back_drb->offset;
+         back_drb->flippedPitch   = back_drb->pitch;
+         back_drb->flippedData    = back_drb->Base.Data;
+      }
+   }
+}
+
+
+/**
+ * Check that the gl_framebuffer associated with dPriv is the right size.
+ * Resize the gl_framebuffer if needed.
+ * It's expected that the dPriv->driverPrivate member points to a
+ * gl_framebuffer object.
+ */
+void
+driUpdateFramebufferSize(GLcontext *ctx, const __DRIdrawablePrivate *dPriv)
+{
+   struct gl_framebuffer *fb = (struct gl_framebuffer *) dPriv->driverPrivate;
+   if (fb && (dPriv->w != fb->Width || dPriv->h != fb->Height)) {
+      _mesa_resize_framebuffer(ctx, fb, dPriv->w, dPriv->h);
+      assert(fb->Width == dPriv->w);
+      assert(fb->Height == dPriv->h);
+   }
+}
diff --git a/src/mesa/drivers/dri/common/drirenderbuffer.h b/src/mesa/drivers/dri/common/drirenderbuffer.h
new file mode 100644
index 0000000..cd73b78
--- /dev/null
+++ b/src/mesa/drivers/dri/common/drirenderbuffer.h
@@ -0,0 +1,75 @@
+
+/**
+ * A driRenderbuffer is dervied from gl_renderbuffer.
+ * It describes a color buffer (front or back), a depth buffer, or stencil
+ * buffer etc.
+ * Specific to DRI drivers are the offset and pitch fields.
+ */
+
+
+#ifndef DRIRENDERBUFFER_H
+#define DRIRENDERBUFFER_H
+
+#include "mtypes.h"
+#include "dri_util.h"
+
+
+typedef struct {
+   struct gl_renderbuffer Base;
+
+   /* Chars or bytes per pixel.  If Z and Stencil are stored together this
+    * will typically be 32 whether this a depth or stencil renderbuffer.
+    */
+   GLint cpp;
+
+   /* Buffer position and pitch (row stride).  Recall that for today's DRI
+    * drivers, we have statically allocated color/depth/stencil buffers.
+    * So this information describes the whole screen, not just a window.
+    * To address pixels in a window, we need to know the window's position
+    * and size with respect to the screen.
+    */
+   GLint offset;  /* in bytes */
+   GLint pitch;   /* in pixels */
+
+   /* If the driver can do page flipping (full-screen double buffering)
+    * the current front/back buffers may get swapped.
+    * If page flipping is disabled, these  fields will be identical to
+    * the offset/pitch/Data above.
+    * If page flipping is enabled, and this is the front(back) renderbuffer,
+    * flippedOffset/Pitch/Data will have the back(front) renderbuffer's values.
+    */
+   GLint flippedOffset;
+   GLint flippedPitch;
+   GLvoid *flippedData;  /* mmap'd address of buffer memory, if used */
+
+   /* Pointer to corresponding __DRIdrawablePrivate.  This is used to compute
+    * the window's position within the framebuffer.
+    */
+   __DRIdrawablePrivate *dPriv;
+
+   /* XXX this is for radeon/r200 only.  We should really create a new
+    * r200Renderbuffer class, derived from this class...  not a huge deal.
+    */
+   GLboolean depthHasSurface;
+
+   /* XXX this is for s3v only.  A handy flag to know if this is the back
+    * color buffer.
+    */
+   GLboolean backBuffer;
+} driRenderbuffer;
+
+
+extern driRenderbuffer *
+driNewRenderbuffer(GLenum format, GLvoid *addr,
+                   GLint cpp, GLint offset, GLint pitch,
+                   __DRIdrawablePrivate *dPriv);
+
+extern void
+driFlipRenderbuffers(struct gl_framebuffer *fb, GLboolean flipped);
+
+
+extern void
+driUpdateFramebufferSize(GLcontext *ctx, const __DRIdrawablePrivate *dPriv);
+
+
+#endif /* DRIRENDERBUFFER_H */
diff --git a/src/mesa/drivers/dri/common/extension_helper.h b/src/mesa/drivers/dri/common/extension_helper.h
new file mode 100644
index 0000000..5cf83a9
--- /dev/null
+++ b/src/mesa/drivers/dri/common/extension_helper.h
@@ -0,0 +1,6021 @@
+/* DO NOT EDIT - This file generated automatically by extension_helper.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2005
+ * 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
+ * IBM,
+ * 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 "utils.h"
+#include "dispatch.h"
+
+#ifndef NULL
+# define NULL 0
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char UniformMatrix3fvARB_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glUniformMatrix3fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char ProgramParameter4fNV_names[] = 
+    "iiffff\0" /* Parameter signature */
+    "glProgramParameter4fNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_multisample)
+static const char SampleCoverageARB_names[] = 
+    "fi\0" /* Parameter signature */
+    "glSampleCoverage\0"
+    "glSampleCoverageARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char ConvolutionFilter1D_names[] = 
+    "iiiiip\0" /* Parameter signature */
+    "glConvolutionFilter1D\0"
+    "glConvolutionFilter1DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_occlusion_query)
+static const char BeginQueryARB_names[] = 
+    "ii\0" /* Parameter signature */
+    "glBeginQuery\0"
+    "glBeginQueryARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_NV_point_sprite)
+static const char PointParameteriNV_names[] = 
+    "ii\0" /* Parameter signature */
+    "glPointParameteri\0"
+    "glPointParameteriNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3sARB_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glMultiTexCoord3s\0"
+    "glMultiTexCoord3sARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3iEXT_names[] = 
+    "iii\0" /* Parameter signature */
+    "glSecondaryColor3i\0"
+    "glSecondaryColor3iEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos3fMESA_names[] = 
+    "fff\0" /* Parameter signature */
+    "glWindowPos3f\0"
+    "glWindowPos3fARB\0"
+    "glWindowPos3fMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_pixel_texture)
+static const char PixelTexGenParameterfvSGIS_names[] = 
+    "ip\0" /* Parameter signature */
+    "glPixelTexGenParameterfvSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char ActiveTextureARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glActiveTexture\0"
+    "glActiveTextureARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_blit)
+static const char BlitFramebufferEXT_names[] = 
+    "iiiiiiiiii\0" /* Parameter signature */
+    "glBlitFramebufferEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib4ubvNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4ubvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SGI_color_table)
+static const char GetColorTableParameterfvSGI_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetColorTableParameterfvSGI\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fragment_program)
+static const char GetProgramNamedParameterdvNV_names[] = 
+    "iipp\0" /* Parameter signature */
+    "glGetProgramNamedParameterdvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char Histogram_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glHistogram\0"
+    "glHistogramEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_texture4D)
+static const char TexImage4DSGIS_names[] = 
+    "iiiiiiiiiip\0" /* Parameter signature */
+    "glTexImage4DSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos2dvMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos2dv\0"
+    "glWindowPos2dvARB\0"
+    "glWindowPos2dvMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiColor3fVertex3fvSUN_names[] = 
+    "ppp\0" /* Parameter signature */
+    "glReplacementCodeuiColor3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_paletted_texture)
+static const char GetColorTableParameterivEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetColorTableParameterivEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_blend_equation_separate) || defined(need_GL_ATI_blend_equation_separate)
+static const char BlendEquationSeparateEXT_names[] = 
+    "ii\0" /* Parameter signature */
+    "glBlendEquationSeparateEXT\0"
+    "glBlendEquationSeparateATI\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_list_priority)
+static const char ListParameterfSGIX_names[] = 
+    "iif\0" /* Parameter signature */
+    "glListParameterfSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3bEXT_names[] = 
+    "iii\0" /* Parameter signature */
+    "glSecondaryColor3b\0"
+    "glSecondaryColor3bEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord4fColor4fNormal3fVertex4fvSUN_names[] = 
+    "pppp\0" /* Parameter signature */
+    "glTexCoord4fColor4fNormal3fVertex4fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib4svNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4svNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_vertex_buffer_object)
+static const char GetBufferSubDataARB_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetBufferSubData\0"
+    "glGetBufferSubDataARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_vertex_buffer_object)
+static const char BufferSubDataARB_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glBufferSubData\0"
+    "glBufferSubDataARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fColor4ubVertex3fvSUN_names[] = 
+    "ppp\0" /* Parameter signature */
+    "glTexCoord2fColor4ubVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char ProgramEnvParameter4dvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glProgramEnvParameter4dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib2fARB_names[] = 
+    "iff\0" /* Parameter signature */
+    "glVertexAttrib2fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_shader_debug)
+static const char GetDebugLogLengthMESA_names[] = 
+    "iii\0" /* Parameter signature */
+    "glGetDebugLogLengthMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char GetHistogramParameterivEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetHistogramParameterivEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib3fARB_names[] = 
+    "ifff\0" /* Parameter signature */
+    "glVertexAttrib3fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_occlusion_query)
+static const char GetQueryivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetQueryiv\0"
+    "glGetQueryivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_texture3D)
+static const char TexImage3D_names[] = 
+    "iiiiiiiiip\0" /* Parameter signature */
+    "glTexImage3D\0"
+    "glTexImage3DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiVertex3fvSUN_names[] = 
+    "pp\0" /* Parameter signature */
+    "glReplacementCodeuiVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_occlusion_query)
+static const char GetQueryObjectivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetQueryObjectiv\0"
+    "glGetQueryObjectivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiTexCoord2fVertex3fvSUN_names[] = 
+    "ppp\0" /* Parameter signature */
+    "glReplacementCodeuiTexCoord2fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_texture_compression)
+static const char CompressedTexSubImage2DARB_names[] = 
+    "iiiiiiiip\0" /* Parameter signature */
+    "glCompressedTexSubImage2D\0"
+    "glCompressedTexSubImage2DARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform2fARB_names[] = 
+    "iff\0" /* Parameter signature */
+    "glUniform2fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib1svARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib1svARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs1dvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs1dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform2ivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glUniform2ivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const char GetImageTransformParameterfvHP_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetImageTransformParameterfvHP\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_blend)
+static const char WeightubvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glWeightubvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char CopyConvolutionFilter1D_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glCopyConvolutionFilter1D\0"
+    "glCopyConvolutionFilter1DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiNormal3fVertex3fSUN_names[] = 
+    "iffffff\0" /* Parameter signature */
+    "glReplacementCodeuiNormal3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentMaterialfvSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glFragmentMaterialfvSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_blend_color)
+static const char BlendColor_names[] = 
+    "ffff\0" /* Parameter signature */
+    "glBlendColor\0"
+    "glBlendColorEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char UniformMatrix4fvARB_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glUniformMatrix4fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_APPLE_vertex_array_object)
+static const char DeleteVertexArraysAPPLE_names[] = 
+    "ip\0" /* Parameter signature */
+    "glDeleteVertexArraysAPPLE\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_instruments)
+static const char ReadInstrumentsSGIX_names[] = 
+    "i\0" /* Parameter signature */
+    "glReadInstrumentsSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Color4ubVertex3fvSUN_names[] = 
+    "pp\0" /* Parameter signature */
+    "glColor4ubVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_list_priority)
+static const char GetListParameterivSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetListParameterivSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4NusvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4NusvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+static const char WindowPos4svMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos4svMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char CreateProgramObjectARB_names[] = 
+    "\0" /* Parameter signature */
+    "glCreateProgramObjectARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentLightModelivSGIX_names[] = 
+    "ip\0" /* Parameter signature */
+    "glFragmentLightModelivSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char ColorFragmentOp3ATI_names[] = 
+    "iiiiiiiiiiiii\0" /* Parameter signature */
+    "glColorFragmentOp3ATI\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_texture_object)
+static const char PrioritizeTextures_names[] = 
+    "ipp\0" /* Parameter signature */
+    "glPrioritizeTextures\0"
+    "glPrioritizeTexturesEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_async)
+static const char AsyncMarkerSGIX_names[] = 
+    "i\0" /* Parameter signature */
+    "glAsyncMarkerSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactorubSUN_names[] = 
+    "i\0" /* Parameter signature */
+    "glGlobalAlphaFactorubSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_shader_debug)
+static const char ClearDebugLogMESA_names[] = 
+    "iii\0" /* Parameter signature */
+    "glClearDebugLogMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char ResetHistogram_names[] = 
+    "i\0" /* Parameter signature */
+    "glResetHistogram\0"
+    "glResetHistogramEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fragment_program)
+static const char GetProgramNamedParameterfvNV_names[] = 
+    "iipp\0" /* Parameter signature */
+    "glGetProgramNamedParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_point_parameters) || defined(need_GL_EXT_point_parameters) || defined(need_GL_SGIS_point_parameters)
+static const char PointParameterfEXT_names[] = 
+    "if\0" /* Parameter signature */
+    "glPointParameterf\0"
+    "glPointParameterfARB\0"
+    "glPointParameterfEXT\0"
+    "glPointParameterfSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_polynomial_ffd)
+static const char LoadIdentityDeformationMapSGIX_names[] = 
+    "i\0" /* Parameter signature */
+    "glLoadIdentityDeformationMapSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fence)
+static const char GenFencesNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGenFencesNV\0"
+    "";
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const char ImageTransformParameterfHP_names[] = 
+    "iif\0" /* Parameter signature */
+    "glImageTransformParameterfHP\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_matrix_palette)
+static const char MatrixIndexusvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMatrixIndexusvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char ProgramParameter4dvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glProgramParameter4dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char DisableVertexAttribArrayARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glDisableVertexAttribArrayARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_2_0)
+static const char StencilMaskSeparate_names[] = 
+    "ii\0" /* Parameter signature */
+    "glStencilMaskSeparate\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char ProgramLocalParameter4dARB_names[] = 
+    "iidddd\0" /* Parameter signature */
+    "glProgramLocalParameter4dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_texture_compression)
+static const char CompressedTexImage3DARB_names[] = 
+    "iiiiiiiip\0" /* Parameter signature */
+    "glCompressedTexImage3D\0"
+    "glCompressedTexImage3DARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib1fARB_names[] = 
+    "if\0" /* Parameter signature */
+    "glVertexAttrib1fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fence)
+static const char TestFenceNV_names[] = 
+    "i\0" /* Parameter signature */
+    "glTestFenceNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord1fvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord1fv\0"
+    "glMultiTexCoord1fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char ColorFragmentOp2ATI_names[] = 
+    "iiiiiiiiii\0" /* Parameter signature */
+    "glColorFragmentOp2ATI\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char SecondaryColorPointerListIBM_names[] = 
+    "iiipi\0" /* Parameter signature */
+    "glSecondaryColorPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_pixel_texture)
+static const char GetPixelTexGenParameterivSGIS_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGetPixelTexGenParameterivSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib4fNV_names[] = 
+    "iffff\0" /* Parameter signature */
+    "glVertexAttrib4fNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_triangle_list)
+static const char ReplacementCodeubSUN_names[] = 
+    "i\0" /* Parameter signature */
+    "glReplacementCodeubSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_async)
+static const char FinishAsyncSGIX_names[] = 
+    "p\0" /* Parameter signature */
+    "glFinishAsyncSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_shader_debug)
+static const char GetDebugLogMESA_names[] = 
+    "iiiipp\0" /* Parameter signature */
+    "glGetDebugLogMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_fog_coord)
+static const char FogCoorddEXT_names[] = 
+    "d\0" /* Parameter signature */
+    "glFogCoordd\0"
+    "glFogCoorddEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Color4ubVertex3fSUN_names[] = 
+    "iiiifff\0" /* Parameter signature */
+    "glColor4ubVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_fog_coord)
+static const char FogCoordfEXT_names[] = 
+    "f\0" /* Parameter signature */
+    "glFogCoordf\0"
+    "glFogCoordfEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fVertex3fSUN_names[] = 
+    "fffff\0" /* Parameter signature */
+    "glTexCoord2fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactoriSUN_names[] = 
+    "i\0" /* Parameter signature */
+    "glGlobalAlphaFactoriSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib2dNV_names[] = 
+    "idd\0" /* Parameter signature */
+    "glVertexAttrib2dNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4NbvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4NbvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_shader)
+static const char GetActiveAttribARB_names[] = 
+    "iiipppp\0" /* Parameter signature */
+    "glGetActiveAttribARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib4ubNV_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glVertexAttrib4ubNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fColor4fNormal3fVertex3fSUN_names[] = 
+    "ffffffffffff\0" /* Parameter signature */
+    "glTexCoord2fColor4fNormal3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char GetMinmaxEXT_names[] = 
+    "iiiip\0" /* Parameter signature */
+    "glGetMinmaxEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+static const char CombinerParameterfvNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glCombinerParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs3dvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs3dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs4fvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs4fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentLightiSGIX_names[] = 
+    "iii\0" /* Parameter signature */
+    "glFragmentLightiSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_polygon_offset)
+static const char PolygonOffsetEXT_names[] = 
+    "ff\0" /* Parameter signature */
+    "glPolygonOffsetEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_async)
+static const char PollAsyncSGIX_names[] = 
+    "p\0" /* Parameter signature */
+    "glPollAsyncSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char DeleteFragmentShaderATI_names[] = 
+    "i\0" /* Parameter signature */
+    "glDeleteFragmentShaderATI\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fNormal3fVertex3fvSUN_names[] = 
+    "ppp\0" /* Parameter signature */
+    "glTexCoord2fNormal3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_transpose_matrix)
+static const char MultTransposeMatrixdARB_names[] = 
+    "p\0" /* Parameter signature */
+    "glMultTransposeMatrixd\0"
+    "glMultTransposeMatrixdARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos2svMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos2sv\0"
+    "glWindowPos2svARB\0"
+    "glWindowPos2svMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_texture_compression)
+static const char CompressedTexImage1DARB_names[] = 
+    "iiiiiip\0" /* Parameter signature */
+    "glCompressedTexImage1D\0"
+    "glCompressedTexImage1DARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib2sNV_names[] = 
+    "iii\0" /* Parameter signature */
+    "glVertexAttrib2sNV\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char NormalPointerListIBM_names[] = 
+    "iipi\0" /* Parameter signature */
+    "glNormalPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_vertex_array)
+static const char IndexPointerEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glIndexPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_vertex_array)
+static const char NormalPointerEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glNormalPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3dARB_names[] = 
+    "iddd\0" /* Parameter signature */
+    "glMultiTexCoord3d\0"
+    "glMultiTexCoord3dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord2iARB_names[] = 
+    "iii\0" /* Parameter signature */
+    "glMultiTexCoord2i\0"
+    "glMultiTexCoord2iARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_names[] = 
+    "iffffffff\0" /* Parameter signature */
+    "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord2svARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord2sv\0"
+    "glMultiTexCoord2svARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_triangle_list)
+static const char ReplacementCodeubvSUN_names[] = 
+    "p\0" /* Parameter signature */
+    "glReplacementCodeubvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform3iARB_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glUniform3iARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char GetFragmentMaterialfvSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetFragmentMaterialfvSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Binormal3fEXT_names[] = 
+    "fff\0" /* Parameter signature */
+    "glBinormal3fEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_blend)
+static const char WeightivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glWeightivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactordSUN_names[] = 
+    "d\0" /* Parameter signature */
+    "glGlobalAlphaFactordSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs3fvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs3fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char GenerateMipmapEXT_names[] = 
+    "i\0" /* Parameter signature */
+    "glGenerateMipmapEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char ProgramParameter4dNV_names[] = 
+    "iidddd\0" /* Parameter signature */
+    "glProgramParameter4dNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char SetFragmentShaderConstantATI_names[] = 
+    "ip\0" /* Parameter signature */
+    "glSetFragmentShaderConstantATI\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const char GetMapAttribParameterivNV_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetMapAttribParameterivNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char CreateShaderObjectARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glCreateShaderObjectARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_sharpen_texture)
+static const char GetSharpenTexFuncSGIS_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGetSharpenTexFuncSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_vertex_buffer_object)
+static const char BufferDataARB_names[] = 
+    "iipi\0" /* Parameter signature */
+    "glBufferData\0"
+    "glBufferDataARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_array_range)
+static const char FlushVertexArrayRangeNV_names[] = 
+    "\0" /* Parameter signature */
+    "glFlushVertexArrayRangeNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char SampleMapATI_names[] = 
+    "iii\0" /* Parameter signature */
+    "glSampleMapATI\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_vertex_array)
+static const char VertexPointerEXT_names[] = 
+    "iiiip\0" /* Parameter signature */
+    "glVertexPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_texture_filter4)
+static const char GetTexFilterFuncSGIS_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetTexFilterFuncSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+static const char GetCombinerOutputParameterfvNV_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetCombinerOutputParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_subtexture)
+static const char TexSubImage1D_names[] = 
+    "iiiiiip\0" /* Parameter signature */
+    "glTexSubImage1D\0"
+    "glTexSubImage1DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib1sARB_names[] = 
+    "ii\0" /* Parameter signature */
+    "glVertexAttrib1sARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+static const char FinalCombinerInputNV_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glFinalCombinerInputNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char GetHistogramParameterfvEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetHistogramParameterfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_flush_raster)
+static const char FlushRasterSGIX_names[] = 
+    "\0" /* Parameter signature */
+    "glFlushRasterSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiTexCoord2fVertex3fSUN_names[] = 
+    "ifffff\0" /* Parameter signature */
+    "glReplacementCodeuiTexCoord2fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_draw_buffers) || defined(need_GL_ATI_draw_buffers)
+static const char DrawBuffersARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glDrawBuffersARB\0"
+    "glDrawBuffersATI\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char IsRenderbufferEXT_names[] = 
+    "i\0" /* Parameter signature */
+    "glIsRenderbufferEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_2_0)
+static const char StencilOpSeparate_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glStencilOpSeparate\0"
+    "";
+#endif
+
+#if defined(need_GL_SGI_color_table)
+static const char ColorTableParameteriv_names[] = 
+    "iip\0" /* Parameter signature */
+    "glColorTableParameteriv\0"
+    "glColorTableParameterivSGI\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char FogCoordPointerListIBM_names[] = 
+    "iipi\0" /* Parameter signature */
+    "glFogCoordPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos3dMESA_names[] = 
+    "ddd\0" /* Parameter signature */
+    "glWindowPos3d\0"
+    "glWindowPos3dARB\0"
+    "glWindowPos3dMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_point_parameters) || defined(need_GL_EXT_point_parameters) || defined(need_GL_SGIS_point_parameters)
+static const char PointParameterfvEXT_names[] = 
+    "ip\0" /* Parameter signature */
+    "glPointParameterfv\0"
+    "glPointParameterfvARB\0"
+    "glPointParameterfvEXT\0"
+    "glPointParameterfvSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos2fvMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos2fv\0"
+    "glWindowPos2fvARB\0"
+    "glWindowPos2fvMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3bvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glSecondaryColor3bv\0"
+    "glSecondaryColor3bvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char GetHistogramEXT_names[] = 
+    "iiiip\0" /* Parameter signature */
+    "glGetHistogramEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char VertexPointerListIBM_names[] = 
+    "iiipi\0" /* Parameter signature */
+    "glVertexPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char GetProgramLocalParameterfvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetProgramLocalParameterfvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentMaterialfSGIX_names[] = 
+    "iif\0" /* Parameter signature */
+    "glFragmentMaterialfSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_paletted_texture)
+static const char GetColorTableEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetColorTableEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char RenderbufferStorageEXT_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glRenderbufferStorageEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fence)
+static const char IsFenceNV_names[] = 
+    "i\0" /* Parameter signature */
+    "glIsFenceNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char AttachObjectARB_names[] = 
+    "ii\0" /* Parameter signature */
+    "glAttachObjectARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char GetFragmentLightivSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetFragmentLightivSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char UniformMatrix2fvARB_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glUniformMatrix2fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord2fARB_names[] = 
+    "iff\0" /* Parameter signature */
+    "glMultiTexCoord2f\0"
+    "glMultiTexCoord2fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGI_color_table) || defined(need_GL_EXT_paletted_texture)
+static const char ColorTable_names[] = 
+    "iiiiip\0" /* Parameter signature */
+    "glColorTable\0"
+    "glColorTableSGI\0"
+    "glColorTableEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const char MapControlPointsNV_names[] = 
+    "iiiiiiiip\0" /* Parameter signature */
+    "glMapControlPointsNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char ConvolutionFilter2D_names[] = 
+    "iiiiiip\0" /* Parameter signature */
+    "glConvolutionFilter2D\0"
+    "glConvolutionFilter2DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const char MapParameterfvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glMapParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib3dvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib3dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_PGI_misc_hints)
+static const char HintPGI_names[] = 
+    "ii\0" /* Parameter signature */
+    "glHintPGI\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char ConvolutionParameteriv_names[] = 
+    "iip\0" /* Parameter signature */
+    "glConvolutionParameteriv\0"
+    "glConvolutionParameterivEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_cull_vertex)
+static const char CullParameterdvEXT_names[] = 
+    "ip\0" /* Parameter signature */
+    "glCullParameterdvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fragment_program)
+static const char ProgramNamedParameter4fNV_names[] = 
+    "iipffff\0" /* Parameter signature */
+    "glProgramNamedParameter4fNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Color3fVertex3fSUN_names[] = 
+    "ffffff\0" /* Parameter signature */
+    "glColor3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char ProgramEnvParameter4fvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glProgramEnvParameter4fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentLightModeliSGIX_names[] = 
+    "ii\0" /* Parameter signature */
+    "glFragmentLightModeliSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char ConvolutionParameterfv_names[] = 
+    "iip\0" /* Parameter signature */
+    "glConvolutionParameterfv\0"
+    "glConvolutionParameterfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_3DFX_tbuffer)
+static const char TbufferMask3DFX_names[] = 
+    "i\0" /* Parameter signature */
+    "glTbufferMask3DFX\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char LoadProgramNV_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glLoadProgramNV\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib4fvNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char GetAttachedObjectsARB_names[] = 
+    "iipp\0" /* Parameter signature */
+    "glGetAttachedObjectsARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform3fvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glUniform3fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_draw_range_elements)
+static const char DrawRangeElements_names[] = 
+    "iiiiip\0" /* Parameter signature */
+    "glDrawRangeElements\0"
+    "glDrawRangeElementsEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_sprite)
+static const char SpriteParameterfvSGIX_names[] = 
+    "ip\0" /* Parameter signature */
+    "glSpriteParameterfvSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char CheckFramebufferStatusEXT_names[] = 
+    "i\0" /* Parameter signature */
+    "glCheckFramebufferStatusEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactoruiSUN_names[] = 
+    "i\0" /* Parameter signature */
+    "glGlobalAlphaFactoruiSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char GetHandleARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glGetHandleARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char GetVertexAttribivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetVertexAttribivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+static const char GetCombinerInputParameterfvNV_names[] = 
+    "iiiip\0" /* Parameter signature */
+    "glGetCombinerInputParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiNormal3fVertex3fvSUN_names[] = 
+    "ppp\0" /* Parameter signature */
+    "glReplacementCodeuiNormal3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_transpose_matrix)
+static const char LoadTransposeMatrixdARB_names[] = 
+    "p\0" /* Parameter signature */
+    "glLoadTransposeMatrixd\0"
+    "glLoadTransposeMatrixdARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_2_0)
+static const char StencilFuncSeparate_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glStencilFuncSeparate\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3sEXT_names[] = 
+    "iii\0" /* Parameter signature */
+    "glSecondaryColor3s\0"
+    "glSecondaryColor3sEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Color3fVertex3fvSUN_names[] = 
+    "pp\0" /* Parameter signature */
+    "glColor3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactorbSUN_names[] = 
+    "i\0" /* Parameter signature */
+    "glGlobalAlphaFactorbSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const char ImageTransformParameterfvHP_names[] = 
+    "iip\0" /* Parameter signature */
+    "glImageTransformParameterfvHP\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4ivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4ivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib3fNV_names[] = 
+    "ifff\0" /* Parameter signature */
+    "glVertexAttrib3fNV\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs2dvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs2dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_timer_query)
+static const char GetQueryObjectui64vEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetQueryObjectui64vEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3fvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord3fv\0"
+    "glMultiTexCoord3fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3dEXT_names[] = 
+    "ddd\0" /* Parameter signature */
+    "glSecondaryColor3d\0"
+    "glSecondaryColor3dEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char GetProgramParameterfvNV_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetProgramParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char TangentPointerEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glTangentPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Color4fNormal3fVertex3fvSUN_names[] = 
+    "ppp\0" /* Parameter signature */
+    "glColor4fNormal3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_instruments)
+static const char GetInstrumentsSGIX_names[] = 
+    "\0" /* Parameter signature */
+    "glGetInstrumentsSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const char EvalMapsNV_names[] = 
+    "ii\0" /* Parameter signature */
+    "glEvalMapsNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_subtexture)
+static const char TexSubImage2D_names[] = 
+    "iiiiiiiip\0" /* Parameter signature */
+    "glTexSubImage2D\0"
+    "glTexSubImage2DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentLightivSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glFragmentLightivSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char DeleteRenderbuffersEXT_names[] = 
+    "ip\0" /* Parameter signature */
+    "glDeleteRenderbuffersEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_pixel_transform)
+static const char PixelTransformParameterfvEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glPixelTransformParameterfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4bvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4bvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char AlphaFragmentOp2ATI_names[] = 
+    "iiiiiiiii\0" /* Parameter signature */
+    "glAlphaFragmentOp2ATI\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char GetSeparableFilterEXT_names[] = 
+    "iiippp\0" /* Parameter signature */
+    "glGetSeparableFilterEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord4sARB_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glMultiTexCoord4s\0"
+    "glMultiTexCoord4sARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char GetFragmentMaterialivSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetFragmentMaterialivSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+static const char WindowPos4dMESA_names[] = 
+    "dddd\0" /* Parameter signature */
+    "glWindowPos4dMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_blend)
+static const char WeightPointerARB_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glWeightPointerARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos2dMESA_names[] = 
+    "dd\0" /* Parameter signature */
+    "glWindowPos2d\0"
+    "glWindowPos2dARB\0"
+    "glWindowPos2dMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char FramebufferTexture3DEXT_names[] = 
+    "iiiiii\0" /* Parameter signature */
+    "glFramebufferTexture3DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_blend_minmax)
+static const char BlendEquation_names[] = 
+    "i\0" /* Parameter signature */
+    "glBlendEquation\0"
+    "glBlendEquationEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib3dNV_names[] = 
+    "iddd\0" /* Parameter signature */
+    "glVertexAttrib3dNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib3dARB_names[] = 
+    "iddd\0" /* Parameter signature */
+    "glVertexAttrib3dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_names[] = 
+    "ppppp\0" /* Parameter signature */
+    "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4fARB_names[] = 
+    "iffff\0" /* Parameter signature */
+    "glVertexAttrib4fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_index_func)
+static const char IndexFuncEXT_names[] = 
+    "if\0" /* Parameter signature */
+    "glIndexFuncEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_list_priority)
+static const char GetListParameterfvSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetListParameterfvSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord2dvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord2dv\0"
+    "glMultiTexCoord2dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_cull_vertex)
+static const char CullParameterfvEXT_names[] = 
+    "ip\0" /* Parameter signature */
+    "glCullParameterfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fragment_program)
+static const char ProgramNamedParameter4fvNV_names[] = 
+    "iipp\0" /* Parameter signature */
+    "glProgramNamedParameter4fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColorPointerEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glSecondaryColorPointer\0"
+    "glSecondaryColorPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4fvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char ColorPointerListIBM_names[] = 
+    "iiipi\0" /* Parameter signature */
+    "glColorPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char GetActiveUniformARB_names[] = 
+    "iiipppp\0" /* Parameter signature */
+    "glGetActiveUniformARB\0"
+    "";
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const char ImageTransformParameteriHP_names[] = 
+    "iii\0" /* Parameter signature */
+    "glImageTransformParameteriHP\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord1svARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord1sv\0"
+    "glMultiTexCoord1svARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_occlusion_query)
+static const char EndQueryARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glEndQuery\0"
+    "glEndQueryARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fence)
+static const char DeleteFencesNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glDeleteFencesNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_polynomial_ffd)
+static const char DeformationMap3dSGIX_names[] = 
+    "iddiiddiiddiip\0" /* Parameter signature */
+    "glDeformationMap3dSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const char GetImageTransformParameterivHP_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetImageTransformParameterivHP\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+static const char WindowPos4ivMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos4ivMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3svARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord3sv\0"
+    "glMultiTexCoord3svARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord4iARB_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glMultiTexCoord4i\0"
+    "glMultiTexCoord4iARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Binormal3ivEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glBinormal3ivEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_resize_buffers)
+static const char ResizeBuffersMESA_names[] = 
+    "\0" /* Parameter signature */
+    "glResizeBuffersMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char GetUniformivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetUniformivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_pixel_texture)
+static const char PixelTexGenParameteriSGIS_names[] = 
+    "ii\0" /* Parameter signature */
+    "glPixelTexGenParameteriSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_INTEL_parallel_arrays)
+static const char VertexPointervINTEL_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexPointervINTEL\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiColor4fNormal3fVertex3fvSUN_names[] = 
+    "pppp\0" /* Parameter signature */
+    "glReplacementCodeuiColor4fNormal3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3uiEXT_names[] = 
+    "iii\0" /* Parameter signature */
+    "glSecondaryColor3ui\0"
+    "glSecondaryColor3uiEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_instruments)
+static const char StartInstrumentsSGIX_names[] = 
+    "\0" /* Parameter signature */
+    "glStartInstrumentsSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3usvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glSecondaryColor3usv\0"
+    "glSecondaryColor3usvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib2fvNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib2fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char ProgramLocalParameter4dvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glProgramLocalParameter4dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_matrix_palette)
+static const char MatrixIndexuivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMatrixIndexuivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Tangent3sEXT_names[] = 
+    "iii\0" /* Parameter signature */
+    "glTangent3sEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactorfSUN_names[] = 
+    "f\0" /* Parameter signature */
+    "glGlobalAlphaFactorfSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3iARB_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glMultiTexCoord3i\0"
+    "glMultiTexCoord3iARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char GetConvolutionFilterEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetConvolutionFilterEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char TexCoordPointerListIBM_names[] = 
+    "iiipi\0" /* Parameter signature */
+    "glTexCoordPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const char GlobalAlphaFactorusSUN_names[] = 
+    "i\0" /* Parameter signature */
+    "glGlobalAlphaFactorusSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib2dvNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib2dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char FramebufferRenderbufferEXT_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glFramebufferRenderbufferEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib1dvNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib1dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fence)
+static const char SetFenceNV_names[] = 
+    "ii\0" /* Parameter signature */
+    "glSetFenceNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char FramebufferTexture1DEXT_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glFramebufferTexture1DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+static const char GetCombinerOutputParameterivNV_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetCombinerOutputParameterivNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_pixel_texture)
+static const char PixelTexGenParameterivSGIS_names[] = 
+    "ip\0" /* Parameter signature */
+    "glPixelTexGenParameterivSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_texture_perturb_normal)
+static const char TextureNormalEXT_names[] = 
+    "i\0" /* Parameter signature */
+    "glTextureNormalEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const char IndexPointerListIBM_names[] = 
+    "iipi\0" /* Parameter signature */
+    "glIndexPointerListIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_blend)
+static const char WeightfvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glWeightfvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char ProgramParameter4fvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glProgramParameter4fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+static const char WindowPos4fMESA_names[] = 
+    "ffff\0" /* Parameter signature */
+    "glWindowPos4fMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos3dvMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos3dv\0"
+    "glWindowPos3dvARB\0"
+    "glWindowPos3dvMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_timer_query)
+static const char GetQueryObjecti64vEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetQueryObjecti64vEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord1dARB_names[] = 
+    "id\0" /* Parameter signature */
+    "glMultiTexCoord1d\0"
+    "glMultiTexCoord1dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_NV_point_sprite)
+static const char PointParameterivNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glPointParameteriv\0"
+    "glPointParameterivNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform2fvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glUniform2fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3dvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord3dv\0"
+    "glMultiTexCoord3dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_names[] = 
+    "pppp\0" /* Parameter signature */
+    "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char DeleteObjectARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glDeleteObjectARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char UseProgramObjectARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glUseProgramObjectARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fragment_program)
+static const char ProgramNamedParameter4dvNV_names[] = 
+    "iipp\0" /* Parameter signature */
+    "glProgramNamedParameter4dvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Tangent3fvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glTangent3fvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char BindFramebufferEXT_names[] = 
+    "ii\0" /* Parameter signature */
+    "glBindFramebufferEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4usvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4usvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_compiled_vertex_array)
+static const char UnlockArraysEXT_names[] = 
+    "\0" /* Parameter signature */
+    "glUnlockArraysEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fColor3fVertex3fSUN_names[] = 
+    "ffffffff\0" /* Parameter signature */
+    "glTexCoord2fColor3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos3fvMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos3fv\0"
+    "glWindowPos3fvARB\0"
+    "glWindowPos3fvMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib1svNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib1svNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_copy_texture)
+static const char CopyTexSubImage3D_names[] = 
+    "iiiiiiiii\0" /* Parameter signature */
+    "glCopyTexSubImage3D\0"
+    "glCopyTexSubImage3DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib2dARB_names[] = 
+    "idd\0" /* Parameter signature */
+    "glVertexAttrib2dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_texture_color_mask)
+static const char TextureColorMaskSGIS_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glTextureColorMaskSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_SGI_color_table)
+static const char CopyColorTable_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glCopyColorTable\0"
+    "glCopyColorTableSGI\0"
+    "";
+#endif
+
+#if defined(need_GL_INTEL_parallel_arrays)
+static const char ColorPointervINTEL_names[] = 
+    "iip\0" /* Parameter signature */
+    "glColorPointervINTEL\0"
+    "";
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+static const char AlphaFragmentOp1ATI_names[] = 
+    "iiiiii\0" /* Parameter signature */
+    "glAlphaFragmentOp1ATI\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord3ivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord3iv\0"
+    "glMultiTexCoord3ivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord2sARB_names[] = 
+    "iii\0" /* Parameter signature */
+    "glMultiTexCoord2s\0"
+    "glMultiTexCoord2sARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib1dvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib1dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_texture_object)
+static const char DeleteTextures_names[] = 
+    "ip\0" /* Parameter signature */
+    "glDeleteTextures\0"
+    "glDeleteTexturesEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_vertex_array)
+static const char TexCoordPointerEXT_names[] = 
+    "iiiip\0" /* Parameter signature */
+    "glTexCoordPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_texture4D)
+static const char TexSubImage4DSGIS_names[] = 
+    "iiiiiiiiiiiip\0" /* Parameter signature */
+    "glTexSubImage4DSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners2)
+static const char CombinerStageParameterfvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glCombinerStageParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_instruments)
+static const char StopInstrumentsSGIX_names[] = 
+    "i\0" /* Parameter signature */
+    "glStopInstrumentsSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord4fColor4fNormal3fVertex4fSUN_names[] = 
+    "fffffffffffffff\0" /* Parameter signature */
+    "glTexCoord4fColor4fNormal3fVertex4fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_polynomial_ffd)
+static const char DeformSGIX_names[] = 
+    "i\0" /* Parameter signature */
+    "glDeformSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char GetVertexAttribfvARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetVertexAttribfvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3ivEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glSecondaryColor3iv\0"
+    "glSecondaryColor3ivEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_detail_texture)
+static const char GetDetailTexFuncSGIS_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGetDetailTexFuncSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners2)
+static const char GetCombinerStageParameterfvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetCombinerStageParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Color4ubVertex2fvSUN_names[] = 
+    "pp\0" /* Parameter signature */
+    "glColor4ubVertex2fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_texture_filter4)
+static const char TexFilterFuncSGIS_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glTexFilterFuncSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_multisample) || defined(need_GL_EXT_multisample)
+static const char SampleMaskSGIS_names[] = 
+    "fi\0" /* Parameter signature */
+    "glSampleMaskSGIS\0"
+    "glSampleMaskEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_shader)
+static const char GetAttribLocationARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGetAttribLocationARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4ubvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4ubvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIS_detail_texture)
+static const char DetailTexFuncSGIS_names[] = 
+    "iip\0" /* Parameter signature */
+    "glDetailTexFuncSGIS\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char Normal3fVertex3fSUN_names[] = 
+    "ffffff\0" /* Parameter signature */
+    "glNormal3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_copy_texture)
+static const char CopyTexImage2D_names[] = 
+    "iiiiiiii\0" /* Parameter signature */
+    "glCopyTexImage2D\0"
+    "glCopyTexImage2DEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_vertex_buffer_object)
+static const char GetBufferPointervARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetBufferPointerv\0"
+    "glGetBufferPointervARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char ProgramEnvParameter4fARB_names[] = 
+    "iiffff\0" /* Parameter signature */
+    "glProgramEnvParameter4fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform3ivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glUniform3ivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_fence)
+static const char GetFenceivNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetFenceivNV\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+static const char WindowPos4dvMESA_names[] = 
+    "p\0" /* Parameter signature */
+    "glWindowPos4dvMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_color_subtable)
+static const char ColorSubTable_names[] = 
+    "iiiiip\0" /* Parameter signature */
+    "glColorSubTable\0"
+    "glColorSubTableEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char MultiTexCoord4ivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glMultiTexCoord4iv\0"
+    "glMultiTexCoord4ivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_gpu_program_parameters)
+static const char ProgramLocalParameters4fvEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glProgramLocalParameters4fvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const char GetMapAttribParameterfvNV_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glGetMapAttribParameterfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4sARB_names[] = 
+    "iiiii\0" /* Parameter signature */
+    "glVertexAttrib4sARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_occlusion_query)
+static const char GetQueryObjectuivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetQueryObjectuiv\0"
+    "glGetQueryObjectuivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const char MapParameterivNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glMapParameterivNV\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+static const char GenRenderbuffersEXT_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGenRenderbuffersEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const char GetConvolutionParameterfvEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetConvolutionParameterfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const char GetMinmaxParameterfvEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetMinmaxParameterfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib2dvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib2dvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_vertex_array)
+static const char EdgeFlagPointerEXT_names[] = 
+    "iip\0" /* Parameter signature */
+    "glEdgeFlagPointerEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs2svNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs2svNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_blend)
+static const char WeightbvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glWeightbvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib2fvARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib2fvARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_5) || defined(need_GL_ARB_vertex_buffer_object)
+static const char GetBufferParameterivARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetBufferParameteriv\0"
+    "glGetBufferParameterivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_list_priority)
+static const char ListParameteriSGIX_names[] = 
+    "iii\0" /* Parameter signature */
+    "glListParameteriSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char ReplacementCodeuiColor4fNormal3fVertex3fSUN_names[] = 
+    "iffffffffff\0" /* Parameter signature */
+    "glReplacementCodeuiColor4fNormal3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_instruments)
+static const char InstrumentsBufferSGIX_names[] = 
+    "ip\0" /* Parameter signature */
+    "glInstrumentsBufferSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4NivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4NivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_triangle_list)
+static const char ReplacementCodeuivSUN_names[] = 
+    "p\0" /* Parameter signature */
+    "glReplacementCodeuivSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_APPLE_vertex_array_object)
+static const char GenVertexArraysAPPLE_names[] = 
+    "ip\0" /* Parameter signature */
+    "glGenVertexArraysAPPLE\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_gpu_program_parameters)
+static const char ProgramEnvParameters4fvEXT_names[] = 
+    "iiip\0" /* Parameter signature */
+    "glProgramEnvParameters4fvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos2iMESA_names[] = 
+    "ii\0" /* Parameter signature */
+    "glWindowPos2i\0"
+    "glWindowPos2iARB\0"
+    "glWindowPos2iMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_EXT_secondary_color)
+static const char SecondaryColor3fvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glSecondaryColor3fv\0"
+    "glSecondaryColor3fvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3) || defined(need_GL_ARB_texture_compression)
+static const char CompressedTexSubImage1DARB_names[] = 
+    "iiiiiip\0" /* Parameter signature */
+    "glCompressedTexSubImage1D\0"
+    "glCompressedTexSubImage1DARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fNormal3fVertex3fSUN_names[] = 
+    "ffffffff\0" /* Parameter signature */
+    "glTexCoord2fNormal3fVertex3fSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char GetVertexAttribivNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetVertexAttribivNV\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char GetProgramStringARB_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetProgramStringARB\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char CompileShaderARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glCompileShaderARB\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+static const char CombinerOutputNV_names[] = 
+    "iiiiiiiiii\0" /* Parameter signature */
+    "glCombinerOutputNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_list_priority)
+static const char ListParameterfvSGIX_names[] = 
+    "iip\0" /* Parameter signature */
+    "glListParameterfvSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Tangent3dvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glTangent3dvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char GetVertexAttribfvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glGetVertexAttribfvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_4) || defined(need_GL_ARB_window_pos) || defined(need_GL_MESA_window_pos)
+static const char WindowPos3sMESA_names[] = 
+    "iii\0" /* Parameter signature */
+    "glWindowPos3s\0"
+    "glWindowPos3sARB\0"
+    "glWindowPos3sMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttrib2svNV_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib2svNV\0"
+    "";
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs1fvNV_names[] = 
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs1fvNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const char TexCoord2fVertex3fvSUN_names[] = 
+    "pp\0" /* Parameter signature */
+    "glTexCoord2fVertex3fvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+static const char WindowPos4sMESA_names[] = 
+    "iiii\0" /* Parameter signature */
+    "glWindowPos4sMESA\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib4NuivARB_names[] = 
+    "ip\0" /* Parameter signature */
+    "glVertexAttrib4NuivARB\0"
+    "";
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+static const char ClientActiveTextureARB_names[] = 
+    "i\0" /* Parameter signature */
+    "glClientActiveTexture\0"
+    "glClientActiveTextureARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_pixel_texture)
+static const char PixelTexGenSGIX_names[] = 
+    "i\0" /* Parameter signature */
+    "glPixelTexGenSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_triangle_list)
+static const char ReplacementCodeusvSUN_names[] = 
+    "p\0" /* Parameter signature */
+    "glReplacementCodeusvSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+static const char Uniform4fARB_names[] = 
+    "iffff\0" /* Parameter signature */
+    "glUniform4fARB\0"
+    "";
+#endif
+
+#if defined(need_GL_IBM_multimode_draw_arrays)
+static const char MultiModeDrawArraysIBM_names[] = 
+    "pppii\0" /* Parameter signature */
+    "glMultiModeDrawArraysIBM\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program) || defined(need_GL_NV_vertex_program)
+static const char IsProgramNV_names[] = 
+    "i\0" /* Parameter signature */
+    "glIsProgramARB\0"
+    "glIsProgramNV\0"
+    "";
+#endif
+
+#if defined(need_GL_SUN_triangle_list)
+static const char ReplacementCodePointerSUN_names[] = 
+    "iip\0" /* Parameter signature */
+    "glReplacementCodePointerSUN\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char ProgramEnvParameter4dARB_names[] = 
+    "iidddd\0" /* Parameter signature */
+    "glProgramEnvParameter4dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_SGI_color_table)
+static const char ColorTableParameterfv_names[] = 
+    "iip\0" /* Parameter signature */
+    "glColorTableParameterfv\0"
+    "glColorTableParameterfvSGI\0"
+    "";
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const char FragmentLightModelfSGIX_names[] = 
+    "if\0" /* Parameter signature */
+    "glFragmentLightModelfSGIX\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Binormal3bvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glBinormal3bvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_EXT_vertex_weighting)
+static const char VertexWeightfvEXT_names[] = 
+    "p\0" /* Parameter signature */
+    "glVertexWeightfvEXT\0"
+    "";
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+static const char VertexAttrib1dARB_names[] = 
+    "id\0" /* Parameter signature */
+    "glVertexAttrib1dARB\0"
+    "";
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const char ImageTransformParameteriv