lots of work on extension management

2 files changed, 637 insertions, 546 deletions

diff --git a/src/mesa/glapi/glapi.c b/src/mesa/glapi/glapi.c
index e8fdef2478..2ca689e6e0 100644
--- a/src/mesa/glapi/glapi.c
+++ b/src/mesa/glapi/glapi.c
@@ -1,4 +1,4 @@
-/* $Id: glapi.c,v 1.9 1999/11/25 18:17:04 brianp Exp $ */
+/* $Id: glapi.c,v 1.10 1999/11/27 21:30:40 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -110,6 +110,19 @@ _glapi_get_dispatch(void)
 }
 
 
+
+/*
+ * Return size of dispatch table struct as number of functions (or
+ * slots).
+ */
+GLuint
+_glapi_get_dispatch_table_size(void)
+{
+   return sizeof(struct _glapi_table) / sizeof(void *);
+}
+
+
+
 /*
  * Get API dispatcher version string.
  * XXX this isn't well defined yet.
@@ -122,114 +135,667 @@ _glapi_get_version(void)
 
 
 /*
- * Return list of hard-coded extension entrypoints in the dispatch table.
- * XXX this isn't well defined yet.
+ * Return list of the hard-coded extension entrypoints in the dispatch table.
  */
-const char *
+const char **
 _glapi_get_extensions(void)
 {
-   return "GL_EXT_paletted_texture GL_EXT_compiled_vertex_array GL_EXT_point_parameters GL_EXT_polygon_offset GL_EXT_blend_minmax GL_EXT_blend_color GL_ARB_multitexture GL_INGR_blend_func_separate GL_MESA_window_pos GL_MESA_resize_buffers";
+   static const char *extensions[] = {
+#ifdef _GLAPI_EXT_paletted_texture
+      "GL_EXT_paletted_texture",
+#endif
+#ifdef _GLAPI_EXT_compiled_vertex_array
+      "GL_EXT_compiled_vertex_array",
+#endif
+#ifdef _GLAPI_EXT_point_parameters
+      "GL_EXT_point_parameters",
+#endif
+#ifdef _GLAPI_EXT_polygon_offset
+      "GL_EXT_polygon_offset",
+#endif
+#ifdef _GLAPI_EXT_blend_minmax
+      "GL_EXT_blend_minmax",
+#endif
+#ifdef _GLAPI_EXT_blend_color
+      "GL_EXT_blend_color",
+#endif
+#ifdef _GLAPI_ARB_multitexture
+      "GL_ARB_multitexture",
+#endif
+#ifdef _GLAPI_INGR_blend_func_separate
+      "GL_INGR_blend_func_separate",
+#endif
+#ifdef _GLAPI_MESA_window_pos
+      "GL_MESA_window_pos",
+#endif
+#ifdef _GLAPI_MESA_resize_buffers
+      "GL_MESA_resize_buffers",
+#endif
+      NULL
+   };
+
+   return extensions;
 }
 
 
 
-/*
- * XXX the following dynamic extension code is just a prototype and
- * not used yet.
- */
-struct _glapi_ext_entrypoint {
+struct name_address_pair {
    const char *Name;
-   GLuint Offset;
+   GLvoid *Address;
 };
 
-#define MAX_EXT_ENTRYPOINTS 100
+static struct name_address_pair static_functions[] = {
+	{ "glAccum", (GLvoid *) glAccum },
+	{ "glAlphaFunc", (GLvoid *) glAlphaFunc },
+	{ "glBegin", (GLvoid *) glBegin },
+	{ "glBitmap", (GLvoid *) glBitmap },
+	{ "glAccum", (GLvoid *) glAccum },
+	{ "glAlphaFunc", (GLvoid *) glAlphaFunc },
+	{ "glBegin", (GLvoid *) glBegin },
+	{ "glBitmap", (GLvoid *) glBitmap },
+	{ "glBlendFunc", (GLvoid *) glBlendFunc },
+	{ "glCallList", (GLvoid *) glCallList },
+	{ "glCallLists", (GLvoid *) glCallLists },
+	{ "glClear", (GLvoid *) glClear },
+	{ "glClearAccum", (GLvoid *) glClearAccum },
+	{ "glClearColor", (GLvoid *) glClearColor },
+	{ "glClearDepth", (GLvoid *) glClearDepth },
+	{ "glClearIndex", (GLvoid *) glClearIndex },
+	{ "glClearStencil", (GLvoid *) glClearStencil },
+	{ "glClipPlane", (GLvoid *) glClipPlane },
+	{ "glColor3b", (GLvoid *) glColor3b },
+	{ "glColor3bv", (GLvoid *) glColor3bv },
+	{ "glColor3d", (GLvoid *) glColor3d },
+	{ "glColor3dv", (GLvoid *) glColor3dv },
+	{ "glColor3f", (GLvoid *) glColor3f },
+	{ "glColor3fv", (GLvoid *) glColor3fv },
+	{ "glColor3i", (GLvoid *) glColor3i },
+	{ "glColor3iv", (GLvoid *) glColor3iv },
+	{ "glColor3s", (GLvoid *) glColor3s },
+	{ "glColor3sv", (GLvoid *) glColor3sv },
+	{ "glColor3ub", (GLvoid *) glColor3ub },
+	{ "glColor3ubv", (GLvoid *) glColor3ubv },
+	{ "glColor3ui", (GLvoid *) glColor3ui },
+	{ "glColor3uiv", (GLvoid *) glColor3uiv },
+	{ "glColor3us", (GLvoid *) glColor3us },
+	{ "glColor3usv", (GLvoid *) glColor3usv },
+	{ "glColor4b", (GLvoid *) glColor4b },
+	{ "glColor4bv", (GLvoid *) glColor4bv },
+	{ "glColor4d", (GLvoid *) glColor4d },
+	{ "glColor4dv", (GLvoid *) glColor4dv },
+	{ "glColor4f", (GLvoid *) glColor4f },
+	{ "glColor4fv", (GLvoid *) glColor4fv },
+	{ "glColor4i", (GLvoid *) glColor4i },
+	{ "glColor4iv", (GLvoid *) glColor4iv },
+	{ "glColor4s", (GLvoid *) glColor4s },
+	{ "glColor4sv", (GLvoid *) glColor4sv },
+	{ "glColor4ub", (GLvoid *) glColor4ub },
+	{ "glColor4ubv", (GLvoid *) glColor4ubv },
+	{ "glColor4ui", (GLvoid *) glColor4ui },
+	{ "glColor4uiv", (GLvoid *) glColor4uiv },
+	{ "glColor4us", (GLvoid *) glColor4us },
+	{ "glColor4usv", (GLvoid *) glColor4usv },
+	{ "glColorMask", (GLvoid *) glColorMask },
+	{ "glColorMaterial", (GLvoid *) glColorMaterial },
+	{ "glCopyPixels", (GLvoid *) glCopyPixels },
+	{ "glCullFace", (GLvoid *) glCullFace },
+	{ "glDeleteLists", (GLvoid *) glDeleteLists },
+	{ "glDepthFunc", (GLvoid *) glDepthFunc },
+	{ "glDepthMask", (GLvoid *) glDepthMask },
+	{ "glDepthRange", (GLvoid *) glDepthRange },
+	{ "glDisable", (GLvoid *) glDisable },
+	{ "glDrawBuffer", (GLvoid *) glDrawBuffer },
+	{ "glDrawPixels", (GLvoid *) glDrawPixels },
+	{ "glEdgeFlag", (GLvoid *) glEdgeFlag },
+	{ "glEdgeFlagv", (GLvoid *) glEdgeFlagv },
+	{ "glEnable", (GLvoid *) glEnable },
+	{ "glEnd", (GLvoid *) glEnd },
+	{ "glEndList", (GLvoid *) glEndList },
+	{ "glEvalCoord1d", (GLvoid *) glEvalCoord1d },
+	{ "glEvalCoord1dv", (GLvoid *) glEvalCoord1dv },
+	{ "glEvalCoord1f", (GLvoid *) glEvalCoord1f },
+	{ "glEvalCoord1fv", (GLvoid *) glEvalCoord1fv },
+	{ "glEvalCoord2d", (GLvoid *) glEvalCoord2d },
+	{ "glEvalCoord2dv", (GLvoid *) glEvalCoord2dv },
+	{ "glEvalCoord2f", (GLvoid *) glEvalCoord2f },
+	{ "glEvalCoord2fv", (GLvoid *) glEvalCoord2fv },
+	{ "glEvalMesh1", (GLvoid *) glEvalMesh1 },
+	{ "glEvalMesh2", (GLvoid *) glEvalMesh2 },
+	{ "glEvalPoint1", (GLvoid *) glEvalPoint1 },
+	{ "glEvalPoint2", (GLvoid *) glEvalPoint2 },
+	{ "glFeedbackBuffer", (GLvoid *) glFeedbackBuffer },
+	{ "glFinish", (GLvoid *) glFinish },
+	{ "glFlush", (GLvoid *) glFlush },
+	{ "glFogf", (GLvoid *) glFogf },
+	{ "glFogfv", (GLvoid *) glFogfv },
+	{ "glFogi", (GLvoid *) glFogi },
+	{ "glFogiv", (GLvoid *) glFogiv },
+	{ "glFrontFace", (GLvoid *) glFrontFace },
+	{ "glFrustum", (GLvoid *) glFrustum },
+	{ "glGenLists", (GLvoid *) glGenLists },
+	{ "glGetBooleanv", (GLvoid *) glGetBooleanv },
+	{ "glGetClipPlane", (GLvoid *) glGetClipPlane },
+	{ "glGetDoublev", (GLvoid *) glGetDoublev },
+	{ "glGetError", (GLvoid *) glGetError },
+	{ "glGetFloatv", (GLvoid *) glGetFloatv },
+	{ "glGetIntegerv", (GLvoid *) glGetIntegerv },
+	{ "glGetLightfv", (GLvoid *) glGetLightfv },
+	{ "glGetLightiv", (GLvoid *) glGetLightiv },
+	{ "glGetMapdv", (GLvoid *) glGetMapdv },
+	{ "glGetMapfv", (GLvoid *) glGetMapfv },
+	{ "glGetMapiv", (GLvoid *) glGetMapiv },
+	{ "glGetMaterialfv", (GLvoid *) glGetMaterialfv },
+	{ "glGetMaterialiv", (GLvoid *) glGetMaterialiv },
+	{ "glGetPixelMapfv", (GLvoid *) glGetPixelMapfv },
+	{ "glGetPixelMapuiv", (GLvoid *) glGetPixelMapuiv },
+	{ "glGetPixelMapusv", (GLvoid *) glGetPixelMapusv },
+	{ "glGetPolygonStipple", (GLvoid *) glGetPolygonStipple },
+	{ "glGetString", (GLvoid *) glGetString },
+	{ "glGetTexEnvfv", (GLvoid *) glGetTexEnvfv },
+	{ "glGetTexEnviv", (GLvoid *) glGetTexEnviv },
+	{ "glGetTexGendv", (GLvoid *) glGetTexGendv },
+	{ "glGetTexGenfv", (GLvoid *) glGetTexGenfv },
+	{ "glGetTexGeniv", (GLvoid *) glGetTexGeniv },
+	{ "glGetTexImage", (GLvoid *) glGetTexImage },
+	{ "glGetTexLevelParameterfv", (GLvoid *) glGetTexLevelParameterfv },
+	{ "glGetTexLevelParameteriv", (GLvoid *) glGetTexLevelParameteriv },
+	{ "glGetTexParameterfv", (GLvoid *) glGetTexParameterfv },
+	{ "glGetTexParameteriv", (GLvoid *) glGetTexParameteriv },
+	{ "glHint", (GLvoid *) glHint },
+	{ "glIndexMask", (GLvoid *) glIndexMask },
+	{ "glIndexd", (GLvoid *) glIndexd },
+	{ "glIndexdv", (GLvoid *) glIndexdv },
+	{ "glIndexf", (GLvoid *) glIndexf },
+	{ "glIndexfv", (GLvoid *) glIndexfv },
+	{ "glIndexi", (GLvoid *) glIndexi },
+	{ "glIndexiv", (GLvoid *) glIndexiv },
+	{ "glIndexs", (GLvoid *) glIndexs },
+	{ "glIndexsv", (GLvoid *) glIndexsv },
+	{ "glInitNames", (GLvoid *) glInitNames },
+	{ "glIsEnabled", (GLvoid *) glIsEnabled },
+	{ "glIsList", (GLvoid *) glIsList },
+	{ "glLightModelf", (GLvoid *) glLightModelf },
+	{ "glLightModelfv", (GLvoid *) glLightModelfv },
+	{ "glLightModeli", (GLvoid *) glLightModeli },
+	{ "glLightModeliv", (GLvoid *) glLightModeliv },
+	{ "glLightf", (GLvoid *) glLightf },
+	{ "glLightfv", (GLvoid *) glLightfv },
+	{ "glLighti", (GLvoid *) glLighti },
+	{ "glLightiv", (GLvoid *) glLightiv },
+	{ "glLineStipple", (GLvoid *) glLineStipple },
+	{ "glLineWidth", (GLvoid *) glLineWidth },
+	{ "glListBase", (GLvoid *) glListBase },
+	{ "glLoadIdentity", (GLvoid *) glLoadIdentity },
+	{ "glLoadMatrixd", (GLvoid *) glLoadMatrixd },
+	{ "glLoadMatrixf", (GLvoid *) glLoadMatrixf },
+	{ "glLoadName", (GLvoid *) glLoadName },
+	{ "glLogicOp", (GLvoid *) glLogicOp },
+	{ "glMap1d", (GLvoid *) glMap1d },
+	{ "glMap1f", (GLvoid *) glMap1f },
+	{ "glMap2d", (GLvoid *) glMap2d },
+	{ "glMap2f", (GLvoid *) glMap2f },
+	{ "glMapGrid1d", (GLvoid *) glMapGrid1d },
+	{ "glMapGrid1f", (GLvoid *) glMapGrid1f },
+	{ "glMapGrid2d", (GLvoid *) glMapGrid2d },
+	{ "glMapGrid2f", (GLvoid *) glMapGrid2f },
+	{ "glMaterialf", (GLvoid *) glMaterialf },
+	{ "glMaterialfv", (GLvoid *) glMaterialfv },
+	{ "glMateriali", (GLvoid *) glMateriali },
+	{ "glMaterialiv", (GLvoid *) glMaterialiv },
+	{ "glMatrixMode", (GLvoid *) glMatrixMode },
+	{ "glMultMatrixd", (GLvoid *) glMultMatrixd },
+	{ "glMultMatrixf", (GLvoid *) glMultMatrixf },
+	{ "glNewList", (GLvoid *) glNewList },
+	{ "glNormal3b", (GLvoid *) glNormal3b },
+	{ "glNormal3bv", (GLvoid *) glNormal3bv },
+	{ "glNormal3d", (GLvoid *) glNormal3d },
+	{ "glNormal3dv", (GLvoid *) glNormal3dv },
+	{ "glNormal3f", (GLvoid *) glNormal3f },
+	{ "glNormal3fv", (GLvoid *) glNormal3fv },
+	{ "glNormal3i", (GLvoid *) glNormal3i },
+	{ "glNormal3iv", (GLvoid *) glNormal3iv },
+	{ "glNormal3s", (GLvoid *) glNormal3s },
+	{ "glNormal3sv", (GLvoid *) glNormal3sv },
+	{ "glOrtho", (GLvoid *) glOrtho },
+	{ "glPassThrough", (GLvoid *) glPassThrough },
+	{ "glPixelMapfv", (GLvoid *) glPixelMapfv },
+	{ "glPixelMapuiv", (GLvoid *) glPixelMapuiv },
+	{ "glPixelMapusv", (GLvoid *) glPixelMapusv },
+	{ "glPixelStoref", (GLvoid *) glPixelStoref },
+	{ "glPixelStorei", (GLvoid *) glPixelStorei },
+	{ "glPixelTransferf", (GLvoid *) glPixelTransferf },
+	{ "glPixelTransferi", (GLvoid *) glPixelTransferi },
+	{ "glPixelZoom", (GLvoid *) glPixelZoom },
+	{ "glPointSize", (GLvoid *) glPointSize },
+	{ "glPolygonMode", (GLvoid *) glPolygonMode },
+	{ "glPolygonOffset", (GLvoid *) glPolygonOffset },
+	{ "glPolygonStipple", (GLvoid *) glPolygonStipple },
+	{ "glPopAttrib", (GLvoid *) glPopAttrib },
+	{ "glPopMatrix", (GLvoid *) glPopMatrix },
+	{ "glPopName", (GLvoid *) glPopName },
+	{ "glPushAttrib", (GLvoid *) glPushAttrib },
+	{ "glPushMatrix", (GLvoid *) glPushMatrix },
+	{ "glPushName", (GLvoid *) glPushName },
+	{ "glRasterPos2d", (GLvoid *) glRasterPos2d },
+	{ "glRasterPos2dv", (GLvoid *) glRasterPos2dv },
+	{ "glRasterPos2f", (GLvoid *) glRasterPos2f },
+	{ "glRasterPos2fv", (GLvoid *) glRasterPos2fv },
+	{ "glRasterPos2i", (GLvoid *) glRasterPos2i },
+	{ "glRasterPos2iv", (GLvoid *) glRasterPos2iv },
+	{ "glRasterPos2s", (GLvoid *) glRasterPos2s },
+	{ "glRasterPos2sv", (GLvoid *) glRasterPos2sv },
+	{ "glRasterPos3d", (GLvoid *) glRasterPos3d },
+	{ "glRasterPos3dv", (GLvoid *) glRasterPos3dv },
+	{ "glRasterPos3f", (GLvoid *) glRasterPos3f },
+	{ "glRasterPos3fv", (GLvoid *) glRasterPos3fv },
+	{ "glRasterPos3i", (GLvoid *) glRasterPos3i },
+	{ "glRasterPos3iv", (GLvoid *) glRasterPos3iv },
+	{ "glRasterPos3s", (GLvoid *) glRasterPos3s },
+	{ "glRasterPos3sv", (GLvoid *) glRasterPos3sv },
+	{ "glRasterPos4d", (GLvoid *) glRasterPos4d },
+	{ "glRasterPos4dv", (GLvoid *) glRasterPos4dv },
+	{ "glRasterPos4f", (GLvoid *) glRasterPos4f },
+	{ "glRasterPos4fv", (GLvoid *) glRasterPos4fv },
+	{ "glRasterPos4i", (GLvoid *) glRasterPos4i },
+	{ "glRasterPos4iv", (GLvoid *) glRasterPos4iv },
+	{ "glRasterPos4s", (GLvoid *) glRasterPos4s },
+	{ "glRasterPos4sv", (GLvoid *) glRasterPos4sv },
+	{ "glReadBuffer", (GLvoid *) glReadBuffer },
+	{ "glReadPixels", (GLvoid *) glReadPixels },
+	{ "glRectd", (GLvoid *) glRectd },
+	{ "glRectdv", (GLvoid *) glRectdv },
+	{ "glRectf", (GLvoid *) glRectf },
+	{ "glRectfv", (GLvoid *) glRectfv },
+	{ "glRecti", (GLvoid *) glRecti },
+	{ "glRectiv", (GLvoid *) glRectiv },
+	{ "glRects", (GLvoid *) glRects },
+	{ "glRectsv", (GLvoid *) glRectsv },
+	{ "glRenderMode", (GLvoid *) glRenderMode },
+	{ "glRotated", (GLvoid *) glRotated },
+	{ "glRotatef", (GLvoid *) glRotatef },
+	{ "glScaled", (GLvoid *) glScaled },
+	{ "glScalef", (GLvoid *) glScalef },
+	{ "glScissor", (GLvoid *) glScissor },
+	{ "glSelectBuffer", (GLvoid *) glSelectBuffer },
+	{ "glShadeModel", (GLvoid *) glShadeModel },
+	{ "glStencilFunc", (GLvoid *) glStencilFunc },
+	{ "glStencilMask", (GLvoid *) glStencilMask },
+	{ "glStencilOp", (GLvoid *) glStencilOp },
+	{ "glTexCoord1d", (GLvoid *) glTexCoord1d },
+	{ "glTexCoord1dv", (GLvoid *) glTexCoord1dv },
+	{ "glTexCoord1f", (GLvoid *) glTexCoord1f },
+	{ "glTexCoord1fv", (GLvoid *) glTexCoord1fv },
+	{ "glTexCoord1i", (GLvoid *) glTexCoord1i },
+	{ "glTexCoord1iv", (GLvoid *) glTexCoord1iv },
+	{ "glTexCoord1s", (GLvoid *) glTexCoord1s },
+	{ "glTexCoord1sv", (GLvoid *) glTexCoord1sv },
+	{ "glTexCoord2d", (GLvoid *) glTexCoord2d },
+	{ "glTexCoord2dv", (GLvoid *) glTexCoord2dv },
+	{ "glTexCoord2f", (GLvoid *) glTexCoord2f },
+	{ "glTexCoord2fv", (GLvoid *) glTexCoord2fv },
+	{ "glTexCoord2i", (GLvoid *) glTexCoord2i },
+	{ "glTexCoord2iv", (GLvoid *) glTexCoord2iv },
+	{ "glTexCoord2s", (GLvoid *) glTexCoord2s },
+	{ "glTexCoord2sv", (GLvoid *) glTexCoord2sv },
+	{ "glTexCoord3d", (GLvoid *) glTexCoord3d },
+	{ "glTexCoord3dv", (GLvoid *) glTexCoord3dv },
+	{ "glTexCoord3f", (GLvoid *) glTexCoord3f },
+	{ "glTexCoord3fv", (GLvoid *) glTexCoord3fv },
+	{ "glTexCoord3i", (GLvoid *) glTexCoord3i },
+	{ "glTexCoord3iv", (GLvoid *) glTexCoord3iv },
+	{ "glTexCoord3s", (GLvoid *) glTexCoord3s },
+	{ "glTexCoord3sv", (GLvoid *) glTexCoord3sv },
+	{ "glTexCoord4d", (GLvoid *) glTexCoord4d },
+	{ "glTexCoord4dv", (GLvoid *) glTexCoord4dv },
+	{ "glTexCoord4f", (GLvoid *) glTexCoord4f },
+	{ "glTexCoord4fv", (GLvoid *) glTexCoord4fv },
+	{ "glTexCoord4i", (GLvoid *) glTexCoord4i },
+	{ "glTexCoord4iv", (GLvoid *) glTexCoord4iv },
+	{ "glTexCoord4s", (GLvoid *) glTexCoord4s },
+	{ "glTexCoord4sv", (GLvoid *) glTexCoord4sv },
+	{ "glTexEnvf", (GLvoid *) glTexEnvf },
+	{ "glTexEnvfv", (GLvoid *) glTexEnvfv },
+	{ "glTexEnvi", (GLvoid *) glTexEnvi },
+	{ "glTexEnviv", (GLvoid *) glTexEnviv },
+	{ "glTexGend", (GLvoid *) glTexGend },
+	{ "glTexGendv", (GLvoid *) glTexGendv },
+	{ "glTexGenf", (GLvoid *) glTexGenf },
+	{ "glTexGenfv", (GLvoid *) glTexGenfv },
+	{ "glTexGeni", (GLvoid *) glTexGeni },
+	{ "glTexGeniv", (GLvoid *) glTexGeniv },
+	{ "glTexImage1D", (GLvoid *) glTexImage1D },
+	{ "glTexImage2D", (GLvoid *) glTexImage2D },
+	{ "glTexParameterf", (GLvoid *) glTexParameterf },
+	{ "glTexParameterfv", (GLvoid *) glTexParameterfv },
+	{ "glTexParameteri", (GLvoid *) glTexParameteri },
+	{ "glTexParameteriv", (GLvoid *) glTexParameteriv },
+	{ "glTranslated", (GLvoid *) glTranslated },
+	{ "glTranslatef", (GLvoid *) glTranslatef },
+	{ "glVertex2d", (GLvoid *) glVertex2d },
+	{ "glVertex2dv", (GLvoid *) glVertex2dv },
+	{ "glVertex2f", (GLvoid *) glVertex2f },
+	{ "glVertex2fv", (GLvoid *) glVertex2fv },
+	{ "glVertex2i", (GLvoid *) glVertex2i },
+	{ "glVertex2iv", (GLvoid *) glVertex2iv },
+	{ "glVertex2s", (GLvoid *) glVertex2s },
+	{ "glVertex2sv", (GLvoid *) glVertex2sv },
+	{ "glVertex3d", (GLvoid *) glVertex3d },
+	{ "glVertex3dv", (GLvoid *) glVertex3dv },
+	{ "glVertex3f", (GLvoid *) glVertex3f },
+	{ "glVertex3fv", (GLvoid *) glVertex3fv },
+	{ "glVertex3i", (GLvoid *) glVertex3i },
+	{ "glVertex3iv", (GLvoid *) glVertex3iv },
+	{ "glVertex3s", (GLvoid *) glVertex3s },
+	{ "glVertex3sv", (GLvoid *) glVertex3sv },
+	{ "glVertex4d", (GLvoid *) glVertex4d },
+	{ "glVertex4dv", (GLvoid *) glVertex4dv },
+	{ "glVertex4f", (GLvoid *) glVertex4f },
+	{ "glVertex4fv", (GLvoid *) glVertex4fv },
+	{ "glVertex4i", (GLvoid *) glVertex4i },
+	{ "glVertex4iv", (GLvoid *) glVertex4iv },
+	{ "glVertex4s", (GLvoid *) glVertex4s },
+	{ "glVertex4sv", (GLvoid *) glVertex4sv },
+	{ "glViewport", (GLvoid *) glViewport },
+
+#ifdef _GLAPI_VERSION_1_1
+	{ "glAreTexturesResident", (GLvoid *) glAreTexturesResident },
+	{ "glArrayElement", (GLvoid *) glArrayElement },
+	{ "glBindTexture", (GLvoid *) glBindTexture },
+	{ "glColorPointer", (GLvoid *) glColorPointer },
+	{ "glCopyTexImage1D", (GLvoid *) glCopyTexImage1D },
+	{ "glCopyTexImage2D", (GLvoid *) glCopyTexImage2D },
+	{ "glCopyTexSubImage1D", (GLvoid *) glCopyTexSubImage1D },
+	{ "glCopyTexSubImage2D", (GLvoid *) glCopyTexSubImage2D },
+	{ "glDeleteTextures", (GLvoid *) glDeleteTextures },
+	{ "glDisableClientState", (GLvoid *) glDisableClientState },
+	{ "glDrawArrays", (GLvoid *) glDrawArrays },
+	{ "glDrawElements", (GLvoid *) glDrawElements },
+	{ "glEdgeFlagPointer", (GLvoid *) glEdgeFlagPointer },
+	{ "glEnableClientState", (GLvoid *) glEnableClientState },
+	{ "glGenTextures", (GLvoid *) glGenTextures },
+	{ "glGetPointerv", (GLvoid *) glGetPointerv },
+	{ "glIndexPointer", (GLvoid *) glIndexPointer },
+	{ "glIndexub", (GLvoid *) glIndexub },
+	{ "glIndexubv", (GLvoid *) glIndexubv },
+	{ "glInterleavedArrays", (GLvoid *) glInterleavedArrays },
+	{ "glIsTexture", (GLvoid *) glIsTexture },
+	{ "glNormalPointer", (GLvoid *) glNormalPointer },
+	{ "glPopClientAttrib", (GLvoid *) glPopClientAttrib },
+	{ "glPrioritizeTextures", (GLvoid *) glPrioritizeTextures },
+	{ "glPushClientAttrib", (GLvoid *) glPushClientAttrib },
+	{ "glTexCoordPointer", (GLvoid *) glTexCoordPointer },
+	{ "glTexSubImage1D", (GLvoid *) glTexSubImage1D },
+	{ "glTexSubImage2D", (GLvoid *) glTexSubImage2D },
+	{ "glVertexPointer", (GLvoid *) glVertexPointer },
+#endif
+
+#ifdef _GLAPI_VERSION_1_2
+	{ "glCopyTexSubImage3D", (GLvoid *) glCopyTexSubImage3D },
+	{ "glDrawRangeElements", (GLvoid *) glDrawRangeElements },
+	{ "glTexImage3D", (GLvoid *) glTexImage3D },
+	{ "glTexSubImage3D", (GLvoid *) glTexSubImage3D },
+
+#ifdef _GLAPI_ARB_imaging
+	{ "glBlendColor", (GLvoid *) glBlendColor },
+	{ "glBlendEquation", (GLvoid *) glBlendEquation },
+	{ "glColorSubTable", (GLvoid *) glColorSubTable },
+	{ "glColorTable", (GLvoid *) glColorTable },
+	{ "glColorTableParameterfv", (GLvoid *) glColorTableParameterfv },
+	{ "glColorTableParameteriv", (GLvoid *) glColorTableParameteriv },
+	{ "glConvolutionFilter1D", (GLvoid *) glConvolutionFilter1D },
+	{ "glConvolutionFilter2D", (GLvoid *) glConvolutionFilter2D },
+	{ "glConvolutionParameterf", (GLvoid *) glConvolutionParameterf },
+	{ "glConvolutionParameterfv", (GLvoid *) glConvolutionParameterfv },
+	{ "glConvolutionParameteri", (GLvoid *) glConvolutionParameteri },
+	{ "glConvolutionParameteriv", (GLvoid *) glConvolutionParameteriv },
+	{ "glCopyColorSubTable", (GLvoid *) glCopyColorSubTable },
+	{ "glCopyColorTable", (GLvoid *) glCopyColorTable },
+	{ "glCopyConvolutionFilter1D", (GLvoid *) glCopyConvolutionFilter1D },
+	{ "glCopyConvolutionFilter2D", (GLvoid *) glCopyConvolutionFilter2D },
+	{ "glGetColorTable", (GLvoid *) glGetColorTable },
+	{ "glGetColorTableParameterfv", (GLvoid *) glGetColorTableParameterfv },
+	{ "glGetColorTableParameteriv", (GLvoid *) glGetColorTableParameteriv },
+	{ "glGetConvolutionFilter", (GLvoid *) glGetConvolutionFilter },
+	{ "glGetConvolutionParameterfv", (GLvoid *) glGetConvolutionParameterfv },
+	{ "glGetConvolutionParameteriv", (GLvoid *) glGetConvolutionParameteriv },
+	{ "glGetHistogram", (GLvoid *) glGetHistogram },
+	{ "glGetHistogramParameterfv", (GLvoid *) glGetHistogramParameterfv },
+	{ "glGetHistogramParameteriv", (GLvoid *) glGetHistogramParameteriv },
+	{ "glGetMinmax", (GLvoid *) glGetMinmax },
+	{ "glGetMinmaxParameterfv", (GLvoid *) glGetMinmaxParameterfv },
+	{ "glGetMinmaxParameteriv", (GLvoid *) glGetMinmaxParameteriv },
+	{ "glGetSeparableFilter", (GLvoid *) glGetSeparableFilter },
+	{ "glHistogram", (GLvoid *) glHistogram },
+	{ "glMinmax", (GLvoid *) glMinmax },
+	{ "glResetHistogram", (GLvoid *) glResetHistogram },
+	{ "glResetMinmax", (GLvoid *) glResetMinmax },
+	{ "glSeparableFilter2D", (GLvoid *) glSeparableFilter2D },
+#endif
+#endif
+
+#ifdef _GLAPI_EXT_paletted_texture
+	{ "glColorTableEXT", (GLvoid *) glColorTableEXT },
+	{ "glColorSubTableEXT", (GLvoid *) glColorSubTableEXT },
+	{ "glGetColorTableEXT", (GLvoid *) glGetColorTableEXT },
+	{ "glGetColorTableParameterfvEXT", (GLvoid *) glGetColorTableParameterfvEXT },
+	{ "glGetColorTableParameterivEXT", (GLvoid *) glGetColorTableParameterivEXT },
+#endif
+
+#ifdef _GLAPI_EXT_compiled_vertex_array
+	{ "glLockArraysEXT", (GLvoid *) glLockArraysEXT },
+	{ "glUnlockArraysEXT", (GLvoid *) glUnlockArraysEXT },
+#endif
+
+#ifdef _GLAPI_EXT_point_parameters
+	{ "glPointParameterfEXT", (GLvoid *) glPointParameterfEXT },
+	{ "glPointParameterfvEXT", (GLvoid *) glPointParameterfvEXT },
+#endif
+
+#ifdef _GLAPI_EXT_polygon_offset
+	{ "glPolygonOffsetEXT", (GLvoid *) glPolygonOffsetEXT },
+#endif
+
+#ifdef _GLAPI_EXT_blend_minmax
+	{ "glBlendEquationEXT", (GLvoid *) glBlendEquationEXT },
+#endif
+
+#ifdef _GLAPI_EXT_blend_color
+	{ "glBlendColorEXT", (GLvoid *) glBlendColorEXT },
+#endif
+
+#ifdef _GLAPI_ARB_multitexture
+	{ "glActiveTextureARB", (GLvoid *) glActiveTextureARB },
+	{ "glClientActiveTextureARB", (GLvoid *) glClientActiveTextureARB },
+	{ "glMultiTexCoord1dARB", (GLvoid *) glMultiTexCoord1dARB },
+	{ "glMultiTexCoord1dvARB", (GLvoid *) glMultiTexCoord1dvARB },
+	{ "glMultiTexCoord1fARB", (GLvoid *) glMultiTexCoord1fARB },
+	{ "glMultiTexCoord1fvARB", (GLvoid *) glMultiTexCoord1fvARB },
+	{ "glMultiTexCoord1iARB", (GLvoid *) glMultiTexCoord1iARB },
+	{ "glMultiTexCoord1ivARB", (GLvoid *) glMultiTexCoord1ivARB },
+	{ "glMultiTexCoord1sARB", (GLvoid *) glMultiTexCoord1sARB },
+	{ "glMultiTexCoord1svARB", (GLvoid *) glMultiTexCoord1svARB },
+	{ "glMultiTexCoord2dARB", (GLvoid *) glMultiTexCoord2dARB },
+	{ "glMultiTexCoord2dvARB", (GLvoid *) glMultiTexCoord2dvARB },
+	{ "glMultiTexCoord2fARB", (GLvoid *) glMultiTexCoord2fARB },
+	{ "glMultiTexCoord2fvARB", (GLvoid *) glMultiTexCoord2fvARB },
+	{ "glMultiTexCoord2iARB", (GLvoid *) glMultiTexCoord2iARB },
+	{ "glMultiTexCoord2ivARB", (GLvoid *) glMultiTexCoord2ivARB },
+	{ "glMultiTexCoord2sARB", (GLvoid *) glMultiTexCoord2sARB },
+	{ "glMultiTexCoord2svARB", (GLvoid *) glMultiTexCoord2svARB },
+	{ "glMultiTexCoord3dARB", (GLvoid *) glMultiTexCoord3dARB },
+	{ "glMultiTexCoord3dvARB", (GLvoid *) glMultiTexCoord3dvARB },
+	{ "glMultiTexCoord3fARB", (GLvoid *) glMultiTexCoord3fARB },
+	{ "glMultiTexCoord3fvARB", (GLvoid *) glMultiTexCoord3fvARB },
+	{ "glMultiTexCoord3iARB", (GLvoid *) glMultiTexCoord3iARB },
+	{ "glMultiTexCoord3ivARB", (GLvoid *) glMultiTexCoord3ivARB },
+	{ "glMultiTexCoord3sARB", (GLvoid *) glMultiTexCoord3sARB },
+	{ "glMultiTexCoord3svARB", (GLvoid *) glMultiTexCoord3svARB },
+	{ "glMultiTexCoord4dARB", (GLvoid *) glMultiTexCoord4dARB },
+	{ "glMultiTexCoord4dvARB", (GLvoid *) glMultiTexCoord4dvARB },
+	{ "glMultiTexCoord4fARB", (GLvoid *) glMultiTexCoord4fARB },
+	{ "glMultiTexCoord4fvARB", (GLvoid *) glMultiTexCoord4fvARB },
+	{ "glMultiTexCoord4iARB", (GLvoid *) glMultiTexCoord4iARB },
+	{ "glMultiTexCoord4ivARB", (GLvoid *) glMultiTexCoord4ivARB },
+	{ "glMultiTexCoord4sARB", (GLvoid *) glMultiTexCoord4sARB },
+	{ "glMultiTexCoord4svARB", (GLvoid *) glMultiTexCoord4svARB },
+#endif
+
+#ifdef _GLAPI_INGR_blend_func_separate
+	{ "glBlendFuncSeparateINGR", (GLvoid *) glBlendFuncSeparateINGR },
+#endif
+
+#ifdef _GLAPI_MESA_window_pos
+	{ "glWindowPos4fMESA", (GLvoid *) glWindowPos4fMESA },
+#endif
+
+#ifdef _GLAPI_MESA_resize_buffers
+	{ "glResizeBuffersMESA", (GLvoid *) glResizeBuffersMESA },
+#endif
 
-static struct _glapi_ext_entrypoint ExtEntryTable[MAX_EXT_ENTRYPOINTS];
-static GLuint NumExtEntryPoints;
+      { NULL, NULL }  /* end of list marker */
+};
 
 
 
 /*
- * Dynamically allocate an extension entry point.
- * Return a slot number or -1 if table is full.
+ * Return dispatch table offset of the named static (built-in) function.
+ * Return -1 if function not found.
  */
-GLint
-_glapi_alloc_entrypoint(const char *funcName)
+static GLint
+get_static_proc_offset(const char *funcName)
 {
    GLuint i;
-   for (i = 0; i < NumExtEntryPoints; i++) {
-      if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
-         /* found it */
-         return (GLint) ExtEntryTable[i].Offset;
+   for (i = 0; static_functions[i].Name; i++) {
+      if (strcmp(static_functions[i].Name, funcName) == 0) {
+         return i;
       }
    }
-   if (NumExtEntryPoints < MAX_EXT_ENTRYPOINTS) {
-      /* add it */
-      ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
-      ExtEntryTable[NumExtEntryPoints].Offset = NumExtEntryPoints; /* OK? */
-      NumExtEntryPoints++;
-      return (GLint) (NumExtEntryPoints - 1);
-   }
-   /* no more room in the table */
    return -1;
 }
 
 
+/*
+ * Return dispatch function address the named static (built-in) function.
+ * Return NULL if function not found.
+ */
+static GLvoid *
+get_static_proc_address(const char *funcName)
+{
+   GLuint i = get_static_proc_offset(funcName);
+   if (i >= 0)
+      return static_functions[i].Address;
+   else
+      return NULL;
+}
+
+
+
+/**********************************************************************
+ * Extension function management.
+ **********************************************************************/
+
+
+struct _glapi_ext_entrypoint {
+   const char *Name;   /* the extension function's name */
+   GLuint Offset;      /* relative to start of dispatch table */
+   GLvoid *Address;    /* address of dispatch function */
+};
+
+static struct _glapi_ext_entrypoint ExtEntryTable[_GLAPI_EXTRA_SLOTS];
+static GLuint NumExtEntryPoints = 0;
+
+
+
+/*
+ * Generate a dispatch function (entrypoint) which jumps through
+ * the given slot number (offset) in the current dispatch table.
+ */
+static void *
+generate_entrypoint(GLuint offset)
+{
+   /* XXX need to generate some assembly code here */
+
+   return NULL;
+}
+
+
 
 /*
- * Find the dynamic entry point for the named function.
- * Return a slot number or -1 if not found.
+ * Add a new extension function entrypoint.
+ * Return: GL_TRUE = success or GL_FALSE = failure
  */
-GLint
-_glapi_get_entrypoint(const char *funcName)
+GLboolean
+_glapi_add_entrypoint(const char *funcName, GLuint offset)
 {
-   GLuint i;
-   for (i = 0; i < NumExtEntryPoints; i++) {
-      if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
-         /* found it */
-         return (GLint) ExtEntryTable[i].Offset;
+   /* first check if the named function is already statically present */
+   GLint index = get_static_proc_offset(funcName);
+   if (index >= 0) {
+      assert(index == offset);
+      return GL_TRUE;
+   }
+   else if (offset < _glapi_get_dispatch_table_size()) {
+      /* be sure index and name match known data */
+      GLuint i;
+      for (i = 0; i < NumExtEntryPoints; i++) {
+         if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
+            /* function already registered with api */
+            if (ExtEntryTable[i].Offset == offset) {
+               return GL_TRUE;  /* offsets match */
+            }
+            else {
+               return GL_FALSE;  /* bad offset! */
+            }
+         }
       }
+      assert(NumExtEntryPoints < _GLAPI_EXTRA_SLOTS);
+      ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
+      ExtEntryTable[NumExtEntryPoints].Offset = offset;
+      ExtEntryTable[NumExtEntryPoints].Address = generate_entrypoint(offset);
+      NumExtEntryPoints++;
+      return GL_TRUE;      
+   }
+   else {
+      return GL_FALSE;
    }
-   /* not in table */
-   return -1;
 }
 
 
 
-static GLvoid *
-get_static_proc_address(const char *funcName)
+/*
+ * Return offset of entrypoint for named function within dispatch table.
+ */
+GLint
+_glapi_get_proc_offset(const char *funcName)
 {
-   struct name_address {
-      const char *Name;
-      GLvoid *Address;
-   };
-   static struct name_address apitable[] = {
-      { "glAccum", (GLvoid *) glAccum },
-      { "glAlphaFunc", (GLvoid *) glAlphaFunc },
-      { "glBegin", (GLvoid *) glBegin },
-      { "glBitmap", (GLvoid *) glBitmap },
-      /* ... many more ... */
-      { NULL, NULL }  /* end of list marker */
-   };
-   GLuint i;
-   for (i = 0; apitable[i].Name; i++) {
-      if (strcmp(apitable[i].Name, funcName) == 0) {
-         return apitable[i].Address;
+   /* search extension functions first */
+   GLint i;
+   for (i = 0; i < NumExtEntryPoints; i++) {
+      if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
+         return ExtEntryTable[i].Offset;
       }
    }
-   return NULL;
+
+   /* search static functions */
+   return get_static_proc_offset(funcName);
 }
 
 
+
 /*
  * Return entrypoint for named function.
  */
 const GLvoid *
 _glapi_get_proc_address(const char *funcName)
 {
-   /* look for dynamic extension entry point */
+   /* search extension functions first */
+   GLint i;
+   for (i = 0; i < NumExtEntryPoints; i++) {
+      if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
+         return ExtEntryTable[i].Address;
+      }
+   }
 
-   /* look for static entry point */
+   /* search static functions */
    return get_static_proc_address(funcName);
 }
 
@@ -713,481 +1279,3 @@ _glapi_check_table(const struct _glapi_table *table)
 
 #include "glapitemp.h"
 
-
-
-#ifdef DEBUG
-/*
- * This struct is just used to be sure we've defined all the API functions.
- */
-static struct _glapi_table completeness_test = {
-   glAccum,
-   glAlphaFunc,
-   glBegin,
-   glBitmap,
-   glBlendFunc,
-   glCallList,
-   glCallLists,
-   glClear,
-   glClearAccum,
-   glClearColor,
-   glClearDepth,
-   glClearIndex,
-   glClearStencil,
-   glClipPlane,
-   glColor3b,
-   glColor3bv,
-   glColor3d,
-   glColor3dv,
-   glColor3f,
-   glColor3fv,
-   glColor3i,
-   glColor3iv,
-   glColor3s,
-   glColor3sv,
-   glColor3ub,
-   glColor3ubv,
-   glColor3ui,
-   glColor3uiv,
-   glColor3us,
-   glColor3usv,
-   glColor4b,
-   glColor4bv,
-   glColor4d,
-   glColor4dv,
-   glColor4f,
-   glColor4fv,
-   glColor4i,
-   glColor4iv,
-   glColor4s,
-   glColor4sv,
-   glColor4ub,
-   glColor4ubv,
-   glColor4ui,
-   glColor4uiv,
-   glColor4us,
-   glColor4usv,
-   glColorMask,
-   glColorMaterial,
-   glCopyPixels,
-   glCullFace,
-   glDeleteLists,
-   glDepthFunc,
-   glDepthMask,
-   glDepthRange,
-   glDisable,
-   glDrawBuffer,
-   glDrawPixels,
-   glEdgeFlag,
-   glEdgeFlagv,
-   glEnable,
-   glEnd,
-   glEndList,
-   glEvalCoord1d,
-   glEvalCoord1dv,
-   glEvalCoord1f,
-   glEvalCoord1fv,
-   glEvalCoord2d,
-   glEvalCoord2dv,
-   glEvalCoord2f,
-   glEvalCoord2fv,
-   glEvalMesh1,
-   glEvalMesh2,
-   glEvalPoint1,
-   glEvalPoint2,
-   glFeedbackBuffer,
-   glFinish,
-   glFlush,
-   glFogf,
-   glFogfv,
-   glFogi,
-   glFogiv,
-   glFrontFace,
-   glFrustum,
-   glGenLists,
-   glGetBooleanv,
-   glGetClipPlane,
-   glGetDoublev,
-   glGetError,
-   glGetFloatv,
-   glGetIntegerv,
-   glGetLightfv,
-   glGetLightiv,
-   glGetMapdv,
-   glGetMapfv,
-   glGetMapiv,
-   glGetMaterialfv,
-   glGetMaterialiv,
-   glGetPixelMapfv,
-   glGetPixelMapuiv,
-   glGetPixelMapusv,
-   glGetPolygonStipple,
-   glGetString,
-   glGetTexEnvfv,
-   glGetTexEnviv,
-   glGetTexGendv,
-   glGetTexGenfv,
-   glGetTexGeniv,
-   glGetTexImage,
-   glGetTexLevelParameterfv,
-   glGetTexLevelParameteriv,
-   glGetTexParameterfv,
-   glGetTexParameteriv,
-   glHint,
-   glIndexMask,
-   glIndexd,
-   glIndexdv,
-   glIndexf,
-   glIndexfv,
-   glIndexi,
-   glIndexiv,
-   glIndexs,
-   glIndexsv,
-   glInitNames,
-   glIsEnabled,
-   glIsList,
-   glLightModelf,
-   glLightModelfv,
-   glLightModeli,
-   glLightModeliv,
-   glLightf,
-   glLightfv,
-   glLighti,
-   glLightiv,
-   glLineStipple,
-   glLineWidth,
-   glListBase,
-   glLoadIdentity,
-   glLoadMatrixd,
-   glLoadMatrixf,
-   glLoadName,
-   glLogicOp,
-   glMap1d,
-   glMap1f,
-   glMap2d,
-   glMap2f,
-   glMapGrid1d,
-   glMapGrid1f,
-   glMapGrid2d,
-   glMapGrid2f,
-   glMaterialf,
-   glMaterialfv,
-   glMateriali,
-   glMaterialiv,
-   glMatrixMode,
-   glMultMatrixd,
-   glMultMatrixf,
-   glNewList,
-   glNormal3b,
-   glNormal3bv,
-   glNormal3d,
-   glNormal3dv,
-   glNormal3f,
-   glNormal3fv,
-   glNormal3i,
-   glNormal3iv,
-   glNormal3s,
-   glNormal3sv,
-   glOrtho,
-   glPassThrough,
-   glPixelMapfv,
-   glPixelMapuiv,
-   glPixelMapusv,
-   glPixelStoref,
-   glPixelStorei,
-   glPixelTransferf,
-   glPixelTransferi,
-   glPixelZoom,
-   glPointSize,
-   glPolygonMode,
-   glPolygonOffset,
-   glPolygonStipple,
-   glPopAttrib,
-   glPopMatrix,
-   glPopName,
-   glPushAttrib,
-   glPushMatrix,
-   glPushName,
-   glRasterPos2d,
-   glRasterPos2dv,
-   glRasterPos2f,
-   glRasterPos2fv,
-   glRasterPos2i,
-   glRasterPos2iv,
-   glRasterPos2s,
-   glRasterPos2sv,
-   glRasterPos3d,
-   glRasterPos3dv,
-   glRasterPos3f,
-   glRasterPos3fv,
-   glRasterPos3i,
-   glRasterPos3iv,
-   glRasterPos3s,
-   glRasterPos3sv,
-   glRasterPos4d,
-   glRasterPos4dv,
-   glRasterPos4f,
-   glRasterPos4fv,
-   glRasterPos4i,
-   glRasterPos4iv,
-   glRasterPos4s,
-   glRasterPos4sv,
-   glReadBuffer,
-   glReadPixels,
-   glRectd,
-   glRectdv,
-   glRectf,
-   glRectfv,
-   glRecti,
-   glRectiv,
-   glRects,
-   glRectsv,
-   glRenderMode,
-   glRotated,
-   glRotatef,
-   glScaled,
-   glScalef,
-   glScissor,
-   glSelectBuffer,
-   glShadeModel,
-   glStencilFunc,
-   glStencilMask,
-   glStencilOp,
-   glTexCoord1d,
-   glTexCoord1dv,
-   glTexCoord1f,
-   glTexCoord1fv,
-   glTexCoord1i,
-   glTexCoord1iv,
-   glTexCoord1s,
-   glTexCoord1sv,
-   glTexCoord2d,
-   glTexCoord2dv,
-   glTexCoord2f,
-   glTexCoord2fv,
-   glTexCoord2i,
-   glTexCoord2iv,
-   glTexCoord2s,
-   glTexCoord2sv,
-   glTexCoord3d,
-   glTexCoord3dv,
-   glTexCoord3f,
-   glTexCoord3fv,
-   glTexCoord3i,
-   glTexCoord3iv,
-   glTexCoord3s,
-   glTexCoord3sv,
-   glTexCoord4d,
-   glTexCoord4dv,
-   glTexCoord4f,
-   glTexCoord4fv,
-   glTexCoord4i,
-   glTexCoord4iv,
-   glTexCoord4s,
-   glTexCoord4sv,
-   glTexEnvf,
-   glTexEnvfv,
-   glTexEnvi,
-   glTexEnviv,
-   glTexGend,
-   glTexGendv,
-   glTexGenf,
-   glTexGenfv,
-   glTexGeni,
-   glTexGeniv,
-   glTexImage1D,
-   glTexImage2D,
-   glTexParameterf,
-   glTexParameterfv,
-   glTexParameteri,
-   glTexParameteriv,
-   glTranslated,
-   glTranslatef,
-   glVertex2d,
-   glVertex2dv,
-   glVertex2f,
-   glVertex2fv,
-   glVertex2i,
-   glVertex2iv,
-   glVertex2s,
-   glVertex2sv,
-   glVertex3d,
-   glVertex3dv,
-   glVertex3f,
-   glVertex3fv,
-   glVertex3i,
-   glVertex3iv,
-   glVertex3s,
-   glVertex3sv,
-   glVertex4d,
-   glVertex4dv,
-   glVertex4f,
-   glVertex4fv,
-   glVertex4i,
-   glVertex4iv,
-   glVertex4s,
-   glVertex4sv,
-   glViewport,
-
-#ifdef _GLAPI_VERSION_1_1
-   glAreTexturesResident,
-   glArrayElement,
-   glBindTexture,
-   glColorPointer,
-   glCopyTexImage1D,
-   glCopyTexImage2D,
-   glCopyTexSubImage1D,
-   glCopyTexSubImage2D,
-   glDeleteTextures,
-   glDisableClientState,
-   glDrawArrays,
-   glDrawElements,
-   glEdgeFlagPointer,
-   glEnableClientState,
-   glGenTextures,
-   glGetPointerv,
-   glIndexPointer,
-   glIndexub,
-   glIndexubv,
-   glInterleavedArrays,
-   glIsTexture,
-   glNormalPointer,
-   glPopClientAttrib,
-   glPrioritizeTextures,
-   glPushClientAttrib,
-   glTexCoordPointer,
-   glTexSubImage1D,
-   glTexSubImage2D,
-   glVertexPointer,
-#endif
-
-#ifdef _GLAPI_VERSION_1_2
-   glCopyTexSubImage3D,
-   glDrawRangeElements,
-   glTexImage3D,
-   glTexSubImage3D,
-
-#ifdef _GLAPI_ARB_imaging
-   glBlendColor,
-   glBlendEquation,
-   glColorSubTable,
-   glColorTable,
-   glColorTableParameterfv,
-   glColorTableParameteriv,
-   glConvolutionFilter1D,
-   glConvolutionFilter2D,
-   glConvolutionParameterf,
-   glConvolutionParameterfv,
-   glConvolutionParameteri,
-   glConvolutionParameteriv,
-   glCopyColorSubTable,
-   glCopyColorTable,
-   glCopyConvolutionFilter1D,
-   glCopyConvolutionFilter2D,
-   glGetColorTable,
-   glGetColorTableParameterfv,
-   glGetColorTableParameteriv,
-   glGetConvolutionFilter,
-   glGetConvolutionParameterfv,
-   glGetConvolutionParameteriv,
-   glGetHistogram,
-   glGetHistogramParameterfv,
-   glGetHistogramParameteriv,
-   glGetMinmax,
-   glGetMinmaxParameterfv,
-   glGetMinmaxParameteriv,
-   glGetSeparableFilter,
-   glHistogram,
-   glMinmax,
-   glResetHistogram,
-   glResetMinmax,
-   glSeparableFilter2D,
-#endif
-#endif
-
-
-   /*
-    * Extensions
-    */
-
-#ifdef _GLAPI_EXT_paletted_texture
-   glColorTableEXT,
-   glColorSubTableEXT,
-   glGetColorTableEXT,
-   glGetColorTableParameterfvEXT,
-   glGetColorTableParameterivEXT,
-#endif
-
-#ifdef _GLAPI_EXT_compiled_vertex_array
-   glLockArraysEXT,
-   glUnlockArraysEXT,
-#endif
-
-#ifdef _GLAPI_EXT_point_parameters
-   glPointParameterfEXT,
-   glPointParameterfvEXT,
-#endif
-
-#ifdef _GLAPI_EXT_polygon_offset
-   glPolygonOffsetEXT,
-#endif
-
-#ifdef _GLAPI_EXT_blend_minmax
-   glBlendEquationEXT,
-#endif
-
-#ifdef _GLAPI_EXT_blend_color
-   glBlendColorEXT,
-#endif
-
-#ifdef _GLAPI_ARB_multitexture
-   glActiveTextureARB,
-   glClientActiveTextureARB,
-   glMultiTexCoord1dARB,
-   glMultiTexCoord1dvARB,
-   glMultiTexCoord1fARB,
-   glMultiTexCoord1fvARB,
-   glMultiTexCoord1iARB,
-   glMultiTexCoord1ivARB,
-   glMultiTexCoord1sARB,
-   glMultiTexCoord1svARB,
-   glMultiTexCoord2dARB,
-   glMultiTexCoord2dvARB,
-   glMultiTexCoord2fARB,
-   glMultiTexCoord2fvARB,
-   glMultiTexCoord2iARB,
-   glMultiTexCoord2ivARB,
-   glMultiTexCoord2sARB,
-   glMultiTexCoord2svARB,
-   glMultiTexCoord3dARB,
-   glMultiTexCoord3dvARB,
-   glMultiTexCoord3fARB,
-   glMultiTexCoord3fvARB,
-   glMultiTexCoord3iARB,
-   glMultiTexCoord3ivARB,
-   glMultiTexCoord3sARB,
-   glMultiTexCoord3svARB,
-   glMultiTexCoord4dARB,
-   glMultiTexCoord4dvARB,
-   glMultiTexCoord4fARB,
-   glMultiTexCoord4fvARB,
-   glMultiTexCoord4iARB,
-   glMultiTexCoord4ivARB,
-   glMultiTexCoord4sARB,
-   glMultiTexCoord4svARB,
-#endif
-
-#ifdef _GLAPI_INGR_blend_func_separate
-   glBlendFuncSeparateINGR,
-#endif
-
-#ifdef _GLAPI_MESA_window_pos
-   glWindowPos4fMESA,
-#endif
-
-#ifdef _GLAPI_MESA_resize_buffers
-   glResizeBuffersMESA
-#endif
-
-};
-
-#endif /*DEBUG*/
diff --git a/src/mesa/glapi/glapi.h b/src/mesa/glapi/glapi.h
index 0baa0c2b50..cfd9d72204 100644
--- a/src/mesa/glapi/glapi.h
+++ b/src/mesa/glapi/glapi.h
@@ -1,4 +1,4 @@
-/* $Id: glapi.h,v 1.3 1999/11/25 18:17:14 brianp Exp $ */
+/* $Id: glapi.h,v 1.4 1999/11/27 21:30:40 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -30,7 +30,6 @@
 
 
 #include "GL/gl.h"
-
 #include "glapitable.h"
 
 
@@ -42,11 +41,15 @@ extern struct _glapi_table *
 _glapi_get_dispatch(void);
 
 
+extern GLuint
+_glapi_get_dispatch_table_size(void);
+
+
 extern const char *
 _glapi_get_version(void);
 
 
-extern const char *
+extern const char **
 _glapi_get_extensions(void);
 
 
@@ -54,12 +57,12 @@ extern void
 _glapi_check_table(const struct _glapi_table *table);
 
 
-extern GLint
-_glapi_alloc_entrypoint(const char *funcName);
+extern GLboolean
+_glapi_add_entrypoint(const char *funcName, GLuint offset);
 
 
 extern GLint
-_glapi_get_entrypoint(const char *funcName);
+_glapi_get_proc_offset(const char *funcName);
 
 
 extern const GLvoid *