Major rip-up of internal function insertion interface. The old

_glapi_add_entrypoint has been replaced by a new routine called
_glapi_add_dispatch.  This new routine dynamically assignes dispatch offsets
to functions added.  This allows IHVs to add support for extension functions
that do not have assigned dispatch offsets.

It also means that a driver has no idea what offset will be assigned to a
function.  The vast majority of the changes in this commit account for that.
An additional table, driDispatchRemapTable, is added.  Functions not in the
Linux OpenGL ABI (i.e., anything not in GL 1.2 + ARB_multitexture) has a
fixed offset in this new table.  The entry in this table specifies the
offset in of the function in the real dispatch table.

The internal interface was also bumped from version 20050725 to 20050727.

This has been tested with various programs in progs/demos on:

radeon (Radeon Mobility M6)
r128 (Rage 128 Pro)
mga (G400)

diff --git a/include/GL/internal/dri_interface.h b/include/GL/internal/dri_interface.h
index 08d3844266c4d98e16b6e2474be8f7a4de1eea89..f4098ba8d91dc64c45d1a8a04457e29c8176f9c7 100644 (file)
--- a/include/GL/internal/dri_interface.h
+++ b/include/GL/internal/dri_interface.h
@@ -113,7 +113,7 @@ typedef void *(CREATENEWSCREENFUNC)(__DRInativeDisplay *dpy, int scrn,
     const __DRIinterfaceMethods * interface,
     __GLcontextModes ** driver_modes);
 typedef CREATENEWSCREENFUNC* PFNCREATENEWSCREENFUNC;
-extern CREATENEWSCREENFUNC __driCreateNewScreen_20050725;
+extern CREATENEWSCREENFUNC __driCreateNewScreen_20050727;
 
 
 /**
@@ -377,7 +377,7 @@ struct __DRIcontextRec {
     /**
      * Method to bind a DRI drawable to a DRI graphics context.
      *
-     * \since Internal API version 20050725.
+     * \since Internal API version 20050727.
      */
     GLboolean (*bindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
                         __DRIid read, __DRIcontext *ctx);
@@ -385,7 +385,7 @@ struct __DRIcontextRec {
     /**
      * Method to unbind a DRI drawable from a DRI graphics context.
      *
-     * \since Internal API version 20050725.
+     * \since Internal API version 20050727.
      */
     GLboolean (*unbindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
                           __DRIid read, __DRIcontext *ctx);

diff --git a/src/glx/x11/dri_glx.c b/src/glx/x11/dri_glx.c
index 91ca875ff16168caa81d6966a78e74a9af72fd50..6ebf21d40284f0f72d9434a900e605f9f0b862ac 100644 (file)
--- a/src/glx/x11/dri_glx.c
+++ b/src/glx/x11/dri_glx.c
@@ -166,7 +166,7 @@ ExtractDir(int index, const char *paths, int dirLen, char *dir)
  * \todo
  * Create a macro or something so that this is automatically updated.
  */
-static const char createNewScreenName[] = "__driCreateNewScreen_20050725";
+static const char createNewScreenName[] = "__driCreateNewScreen_20050727";
 
 
 /**

diff --git a/src/glx/x11/glxcmds.c b/src/glx/x11/glxcmds.c
index 39e5f11e43befbe478d27cdb812385f159a7ecd3..fbb6e7b36810f84a491c7764d250ec7fda1db9b7 100644 (file)
--- a/src/glx/x11/glxcmds.c
+++ b/src/glx/x11/glxcmds.c
@@ -2886,10 +2886,10 @@ int __glXGetInternalVersion(void)
      * 20040415 - Added support for bindContext3 and unbindContext3.
      * 20040602 - Add __glXGetDrawableInfo.  I though that was there
      *            months ago. :(
-     * 20050725 - Gut all the old interfaces.  This breaks compatability with
+     * 20050727 - Gut all the old interfaces.  This breaks compatability with
      *            any DRI driver built to any previous version.
      */
-    return 20050725;
+    return 20050727;
 }
 
 

diff --git a/src/mesa/drivers/dri/common/extension_helper.h b/src/mesa/drivers/dri/common/extension_helper.h
index 39384ca31b43e411f6f9ddff247edcd3a40158a3..4a6606819cfe3f529a44aef2b60aa182e7bd6c18 100644 (file)
--- a/src/mesa/drivers/dri/common/extension_helper.h
+++ b/src/mesa/drivers/dri/common/extension_helper.h
@@ -26,6 +26,7 @@
  */
 
 #include "utils.h"
+#include "dispatch.h"
 
 #ifndef NULL
 # define NULL 0
@@ -4579,1308 +4580,1308 @@ static const char WindowPos2fMESA_names[] =
 
 #if defined(need_GL_3DFX_tbuffer)
 static const struct dri_extension_function GL_3DFX_tbuffer_functions[] = {
-    { TbufferMask3DFX_names, 553 },
-    { NULL, 0 }
+    { TbufferMask3DFX_names, TbufferMask3DFX_remap_index, 553 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_draw_buffers)
 static const struct dri_extension_function GL_ARB_draw_buffers_functions[] = {
-    { DrawBuffersARB_names, 413 },
-    { NULL, 0 }
+    { DrawBuffersARB_names, DrawBuffersARB_remap_index, 413 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_matrix_palette)
 static const struct dri_extension_function GL_ARB_matrix_palette_functions[] = {
-    { MatrixIndexusvARB_names, -1 },
-    { MatrixIndexuivARB_names, -1 },
-    { CurrentPaletteMatrixARB_names, -1 },
-    { MatrixIndexubvARB_names, -1 },
-    { MatrixIndexPointerARB_names, -1 },
-    { NULL, 0 }
+    { MatrixIndexusvARB_names, MatrixIndexusvARB_remap_index, -1 },
+    { MatrixIndexuivARB_names, MatrixIndexuivARB_remap_index, -1 },
+    { CurrentPaletteMatrixARB_names, CurrentPaletteMatrixARB_remap_index, -1 },
+    { MatrixIndexubvARB_names, MatrixIndexubvARB_remap_index, -1 },
+    { MatrixIndexPointerARB_names, MatrixIndexPointerARB_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_multisample)
 static const struct dri_extension_function GL_ARB_multisample_functions[] = {
-    { SampleCoverageARB_names, 412 },
-    { NULL, 0 }
+    { SampleCoverageARB_names, SampleCoverageARB_remap_index, 412 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_occlusion_query)
 static const struct dri_extension_function GL_ARB_occlusion_query_functions[] = {
-    { BeginQueryARB_names, 703 },
-    { GetQueryivARB_names, 705 },
-    { GetQueryObjectivARB_names, 706 },
-    { EndQueryARB_names, 704 },
-    { GetQueryObjectuivARB_names, 707 },
-    { DeleteQueriesARB_names, 701 },
-    { IsQueryARB_names, 702 },
-    { GenQueriesARB_names, 700 },
-    { NULL, 0 }
+    { BeginQueryARB_names, BeginQueryARB_remap_index, 703 },
+    { GetQueryivARB_names, GetQueryivARB_remap_index, 705 },
+    { GetQueryObjectivARB_names, GetQueryObjectivARB_remap_index, 706 },
+    { EndQueryARB_names, EndQueryARB_remap_index, 704 },
+    { GetQueryObjectuivARB_names, GetQueryObjectuivARB_remap_index, 707 },
+    { DeleteQueriesARB_names, DeleteQueriesARB_remap_index, 701 },
+    { IsQueryARB_names, IsQueryARB_remap_index, 702 },
+    { GenQueriesARB_names, GenQueriesARB_remap_index, 700 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_point_parameters)
 static const struct dri_extension_function GL_ARB_point_parameters_functions[] = {
-    { PointParameterfEXT_names, 458 },
-    { PointParameterfvEXT_names, 459 },
-    { NULL, 0 }
+    { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 },
+    { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_shader_objects)
 static const struct dri_extension_function GL_ARB_shader_objects_functions[] = {
-    { UniformMatrix3fvARB_names, 739 },
-    { Uniform2fARB_names, 723 },
-    { Uniform2ivARB_names, 735 },
-    { UniformMatrix4fvARB_names, 740 },
-    { CreateProgramObjectARB_names, 717 },
-    { Uniform3iARB_names, 728 },
-    { CreateShaderObjectARB_names, 714 },
-    { AttachObjectARB_names, 718 },
-    { UniformMatrix2fvARB_names, 738 },
-    { GetAttachedObjectsARB_names, 744 },
-    { Uniform3fvARB_names, 732 },
-    { GetHandleARB_names, 712 },
-    { GetActiveUniformARB_names, 746 },
-    { GetUniformivARB_names, 748 },
-    { Uniform2fvARB_names, 731 },
-    { DeleteObjectARB_names, 711 },
-    { UseProgramObjectARB_names, 720 },
-    { Uniform3ivARB_names, 736 },
-    { CompileShaderARB_names, 716 },
-    { Uniform4fARB_names, 725 },
-    { LinkProgramARB_names, 719 },
-    { ShaderSourceARB_names, 715 },
-    { Uniform4ivARB_names, 737 },
-    { Uniform1ivARB_names, 734 },
-    { ValidateProgramARB_names, 721 },
-    { Uniform1iARB_names, 726 },
-    { Uniform4fvARB_names, 733 },
-    { GetUniformfvARB_names, 747 },
-    { DetachObjectARB_names, 713 },
-    { Uniform4iARB_names, 729 },
-    { Uniform2iARB_names, 727 },
-    { GetObjectParameterivARB_names, 742 },
-    { GetUniformLocationARB_names, 745 },
-    { GetShaderSourceARB_names, 749 },
-    { Uniform1fARB_names, 722 },
-    { Uniform1fvARB_names, 730 },
-    { Uniform3fARB_names, 724 },
-    { GetObjectParameterfvARB_names, 741 },
-    { GetInfoLogARB_names, 743 },
-    { NULL, 0 }
+    { UniformMatrix3fvARB_names, UniformMatrix3fvARB_remap_index, 739 },
+    { Uniform2fARB_names, Uniform2fARB_remap_index, 723 },
+    { Uniform2ivARB_names, Uniform2ivARB_remap_index, 735 },
+    { UniformMatrix4fvARB_names, UniformMatrix4fvARB_remap_index, 740 },
+    { CreateProgramObjectARB_names, CreateProgramObjectARB_remap_index, 717 },
+    { Uniform3iARB_names, Uniform3iARB_remap_index, 728 },
+    { CreateShaderObjectARB_names, CreateShaderObjectARB_remap_index, 714 },
+    { AttachObjectARB_names, AttachObjectARB_remap_index, 718 },
+    { UniformMatrix2fvARB_names, UniformMatrix2fvARB_remap_index, 738 },
+    { GetAttachedObjectsARB_names, GetAttachedObjectsARB_remap_index, 744 },
+    { Uniform3fvARB_names, Uniform3fvARB_remap_index, 732 },
+    { GetHandleARB_names, GetHandleARB_remap_index, 712 },
+    { GetActiveUniformARB_names, GetActiveUniformARB_remap_index, 746 },
+    { GetUniformivARB_names, GetUniformivARB_remap_index, 748 },
+    { Uniform2fvARB_names, Uniform2fvARB_remap_index, 731 },
+    { DeleteObjectARB_names, DeleteObjectARB_remap_index, 711 },
+    { UseProgramObjectARB_names, UseProgramObjectARB_remap_index, 720 },
+    { Uniform3ivARB_names, Uniform3ivARB_remap_index, 736 },
+    { CompileShaderARB_names, CompileShaderARB_remap_index, 716 },
+    { Uniform4fARB_names, Uniform4fARB_remap_index, 725 },
+    { LinkProgramARB_names, LinkProgramARB_remap_index, 719 },
+    { ShaderSourceARB_names, ShaderSourceARB_remap_index, 715 },
+    { Uniform4ivARB_names, Uniform4ivARB_remap_index, 737 },
+    { Uniform1ivARB_names, Uniform1ivARB_remap_index, 734 },
+    { ValidateProgramARB_names, ValidateProgramARB_remap_index, 721 },
+    { Uniform1iARB_names, Uniform1iARB_remap_index, 726 },
+    { Uniform4fvARB_names, Uniform4fvARB_remap_index, 733 },
+    { GetUniformfvARB_names, GetUniformfvARB_remap_index, 747 },
+    { DetachObjectARB_names, DetachObjectARB_remap_index, 713 },
+    { Uniform4iARB_names, Uniform4iARB_remap_index, 729 },
+    { Uniform2iARB_names, Uniform2iARB_remap_index, 727 },
+    { GetObjectParameterivARB_names, GetObjectParameterivARB_remap_index, 742 },
+    { GetUniformLocationARB_names, GetUniformLocationARB_remap_index, 745 },
+    { GetShaderSourceARB_names, GetShaderSourceARB_remap_index, 749 },
+    { Uniform1fARB_names, Uniform1fARB_remap_index, 722 },
+    { Uniform1fvARB_names, Uniform1fvARB_remap_index, 730 },
+    { Uniform3fARB_names, Uniform3fARB_remap_index, 724 },
+    { GetObjectParameterfvARB_names, GetObjectParameterfvARB_remap_index, 741 },
+    { GetInfoLogARB_names, GetInfoLogARB_remap_index, 743 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_texture_compression)
 static const struct dri_extension_function GL_ARB_texture_compression_functions[] = {
-    { CompressedTexSubImage2DARB_names, 558 },
-    { CompressedTexImage3DARB_names, 554 },
-    { CompressedTexImage1DARB_names, 556 },
-    { CompressedTexSubImage1DARB_names, 559 },
-    { CompressedTexSubImage3DARB_names, 557 },
-    { CompressedTexImage2DARB_names, 555 },
-    { GetCompressedTexImageARB_names, 560 },
-    { NULL, 0 }
+    { CompressedTexSubImage2DARB_names, CompressedTexSubImage2DARB_remap_index, 558 },
+    { CompressedTexImage3DARB_names, CompressedTexImage3DARB_remap_index, 554 },
+    { CompressedTexImage1DARB_names, CompressedTexImage1DARB_remap_index, 556 },
+    { CompressedTexSubImage1DARB_names, CompressedTexSubImage1DARB_remap_index, 559 },
+    { CompressedTexSubImage3DARB_names, CompressedTexSubImage3DARB_remap_index, 557 },
+    { CompressedTexImage2DARB_names, CompressedTexImage2DARB_remap_index, 555 },
+    { GetCompressedTexImageARB_names, GetCompressedTexImageARB_remap_index, 560 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_transpose_matrix)
 static const struct dri_extension_function GL_ARB_transpose_matrix_functions[] = {
-    { MultTransposeMatrixdARB_names, 411 },
-    { LoadTransposeMatrixdARB_names, 409 },
-    { MultTransposeMatrixfARB_names, 410 },
-    { LoadTransposeMatrixfARB_names, 408 },
-    { NULL, 0 }
+    { MultTransposeMatrixdARB_names, MultTransposeMatrixdARB_remap_index, 411 },
+    { LoadTransposeMatrixdARB_names, LoadTransposeMatrixdARB_remap_index, 409 },
+    { MultTransposeMatrixfARB_names, MultTransposeMatrixfARB_remap_index, 410 },
+    { LoadTransposeMatrixfARB_names, LoadTransposeMatrixfARB_remap_index, 408 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_vertex_blend)
 static const struct dri_extension_function GL_ARB_vertex_blend_functions[] = {
-    { WeightubvARB_names, -1 },
-    { WeightivARB_names, -1 },
-    { WeightPointerARB_names, -1 },
-    { WeightfvARB_names, -1 },
-    { WeightbvARB_names, -1 },
-    { WeightusvARB_names, -1 },
-    { VertexBlendARB_names, -1 },
-    { WeightsvARB_names, -1 },
-    { WeightdvARB_names, -1 },
-    { WeightuivARB_names, -1 },
-    { NULL, 0 }
+    { WeightubvARB_names, WeightubvARB_remap_index, -1 },
+    { WeightivARB_names, WeightivARB_remap_index, -1 },
+    { WeightPointerARB_names, WeightPointerARB_remap_index, -1 },
+    { WeightfvARB_names, WeightfvARB_remap_index, -1 },
+    { WeightbvARB_names, WeightbvARB_remap_index, -1 },
+    { WeightusvARB_names, WeightusvARB_remap_index, -1 },
+    { VertexBlendARB_names, VertexBlendARB_remap_index, -1 },
+    { WeightsvARB_names, WeightsvARB_remap_index, -1 },
+    { WeightdvARB_names, WeightdvARB_remap_index, -1 },
+    { WeightuivARB_names, WeightuivARB_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_vertex_buffer_object)
 static const struct dri_extension_function GL_ARB_vertex_buffer_object_functions[] = {
-    { GetBufferSubDataARB_names, 695 },
-    { BufferSubDataARB_names, 690 },
-    { BufferDataARB_names, 689 },
-    { GetBufferPointervARB_names, 694 },
-    { GetBufferParameterivARB_names, 693 },
-    { MapBufferARB_names, 697 },
-    { IsBufferARB_names, 696 },
-    { DeleteBuffersARB_names, 691 },
-    { UnmapBufferARB_names, 698 },
-    { BindBufferARB_names, 688 },
-    { GenBuffersARB_names, 692 },
-    { NULL, 0 }
+    { GetBufferSubDataARB_names, GetBufferSubDataARB_remap_index, 695 },
+    { BufferSubDataARB_names, BufferSubDataARB_remap_index, 690 },
+    { BufferDataARB_names, BufferDataARB_remap_index, 689 },
+    { GetBufferPointervARB_names, GetBufferPointervARB_remap_index, 694 },
+    { GetBufferParameterivARB_names, GetBufferParameterivARB_remap_index, 693 },
+    { MapBufferARB_names, MapBufferARB_remap_index, 697 },
+    { IsBufferARB_names, IsBufferARB_remap_index, 696 },
+    { DeleteBuffersARB_names, DeleteBuffersARB_remap_index, 691 },
+    { UnmapBufferARB_names, UnmapBufferARB_remap_index, 698 },
+    { BindBufferARB_names, BindBufferARB_remap_index, 688 },
+    { GenBuffersARB_names, GenBuffersARB_remap_index, 692 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_vertex_program)
 static const struct dri_extension_function GL_ARB_vertex_program_functions[] = {
-    { ProgramEnvParameter4dvARB_names, 669 },
-    { VertexAttrib2fARB_names, 611 },
-    { VertexAttrib3fARB_names, 617 },
-    { VertexAttrib1svARB_names, 608 },
-    { VertexAttrib4NusvARB_names, 662 },
-    { DisableVertexAttribArrayARB_names, 666 },
-    { ProgramLocalParameter4dARB_names, 672 },
-    { VertexAttrib1fARB_names, 605 },
-    { VertexAttrib4NbvARB_names, 659 },
-    { VertexAttrib1sARB_names, 607 },
-    { GetProgramLocalParameterfvARB_names, 679 },
-    { VertexAttrib3dvARB_names, 616 },
-    { ProgramEnvParameter4fvARB_names, 671 },
-    { GetVertexAttribivARB_names, 590 },
-    { VertexAttrib4ivARB_names, 655 },
-    { VertexAttrib4bvARB_names, 654 },
-    { VertexAttrib3dARB_names, 615 },
-    { VertexAttrib4fARB_names, 623 },
-    { VertexAttrib4fvARB_names, 624 },
-    { ProgramLocalParameter4dvARB_names, 673 },
-    { VertexAttrib4usvARB_names, 657 },
-    { VertexAttrib2dARB_names, 609 },
-    { VertexAttrib1dvARB_names, 604 },
-    { GetVertexAttribfvARB_names, 589 },
-    { VertexAttrib4ubvARB_names, 656 },
-    { ProgramEnvParameter4fARB_names, 670 },
-    { VertexAttrib4sARB_names, 625 },
-    { VertexAttrib2dvARB_names, 610 },
-    { VertexAttrib2fvARB_names, 612 },
-    { VertexAttrib4NivARB_names, 661 },
-    { GetProgramStringARB_names, 681 },
-    { VertexAttrib4NuivARB_names, 663 },
-    { IsProgramNV_names, 592 },
-    { ProgramEnvParameter4dARB_names, 668 },
-    { VertexAttrib1dARB_names, 603 },
-    { VertexAttrib3svARB_names, 620 },
-    { GetVertexAttribdvARB_names, 588 },
-    { VertexAttrib4dvARB_names, 622 },
-    { VertexAttribPointerARB_names, 664 },
-    { VertexAttrib4NsvARB_names, 660 },
-    { VertexAttrib3fvARB_names, 618 },
-    { VertexAttrib4NubARB_names, 627 },
-    { GetProgramEnvParameterfvARB_names, 677 },
-    { ProgramLocalParameter4fvARB_names, 675 },
-    { DeleteProgramsNV_names, 580 },
-    { GetVertexAttribPointervNV_names, 591 },
-    { VertexAttrib4dARB_names, 621 },
-    { GetProgramLocalParameterdvARB_names, 678 },
-    { GetProgramivARB_names, 680 },
-    { VertexAttrib3sARB_names, 619 },
-    { ProgramStringARB_names, 667 },
-    { ProgramLocalParameter4fARB_names, 674 },
-    { EnableVertexAttribArrayARB_names, 665 },
-    { VertexAttrib4uivARB_names, 658 },
-    { BindProgramNV_names, 579 },
-    { VertexAttrib4svARB_names, 626 },
-    { VertexAttrib2svARB_names, 614 },
-    { VertexAttrib4NubvARB_names, 628 },
-    { GetProgramEnvParameterdvARB_names, 676 },
-    { VertexAttrib2sARB_names, 613 },
-    { VertexAttrib1fvARB_names, 606 },
-    { GenProgramsNV_names, 582 },
-    { NULL, 0 }
+    { ProgramEnvParameter4dvARB_names, ProgramEnvParameter4dvARB_remap_index, 669 },
+    { VertexAttrib2fARB_names, VertexAttrib2fARB_remap_index, 611 },
+    { VertexAttrib3fARB_names, VertexAttrib3fARB_remap_index, 617 },
+    { VertexAttrib1svARB_names, VertexAttrib1svARB_remap_index, 608 },
+    { VertexAttrib4NusvARB_names, VertexAttrib4NusvARB_remap_index, 662 },
+    { DisableVertexAttribArrayARB_names, DisableVertexAttribArrayARB_remap_index, 666 },
+    { ProgramLocalParameter4dARB_names, ProgramLocalParameter4dARB_remap_index, 672 },
+    { VertexAttrib1fARB_names, VertexAttrib1fARB_remap_index, 605 },
+    { VertexAttrib4NbvARB_names, VertexAttrib4NbvARB_remap_index, 659 },
+    { VertexAttrib1sARB_names, VertexAttrib1sARB_remap_index, 607 },
+    { GetProgramLocalParameterfvARB_names, GetProgramLocalParameterfvARB_remap_index, 679 },
+    { VertexAttrib3dvARB_names, VertexAttrib3dvARB_remap_index, 616 },
+    { ProgramEnvParameter4fvARB_names, ProgramEnvParameter4fvARB_remap_index, 671 },
+    { GetVertexAttribivARB_names, GetVertexAttribivARB_remap_index, 590 },
+    { VertexAttrib4ivARB_names, VertexAttrib4ivARB_remap_index, 655 },
+    { VertexAttrib4bvARB_names, VertexAttrib4bvARB_remap_index, 654 },
+    { VertexAttrib3dARB_names, VertexAttrib3dARB_remap_index, 615 },
+    { VertexAttrib4fARB_names, VertexAttrib4fARB_remap_index, 623 },
+    { VertexAttrib4fvARB_names, VertexAttrib4fvARB_remap_index, 624 },
+    { ProgramLocalParameter4dvARB_names, ProgramLocalParameter4dvARB_remap_index, 673 },
+    { VertexAttrib4usvARB_names, VertexAttrib4usvARB_remap_index, 657 },
+    { VertexAttrib2dARB_names, VertexAttrib2dARB_remap_index, 609 },
+    { VertexAttrib1dvARB_names, VertexAttrib1dvARB_remap_index, 604 },
+    { GetVertexAttribfvARB_names, GetVertexAttribfvARB_remap_index, 589 },
+    { VertexAttrib4ubvARB_names, VertexAttrib4ubvARB_remap_index, 656 },
+    { ProgramEnvParameter4fARB_names, ProgramEnvParameter4fARB_remap_index, 670 },
+    { VertexAttrib4sARB_names, VertexAttrib4sARB_remap_index, 625 },
+    { VertexAttrib2dvARB_names, VertexAttrib2dvARB_remap_index, 610 },
+    { VertexAttrib2fvARB_names, VertexAttrib2fvARB_remap_index, 612 },
+    { VertexAttrib4NivARB_names, VertexAttrib4NivARB_remap_index, 661 },
+    { GetProgramStringARB_names, GetProgramStringARB_remap_index, 681 },
+    { VertexAttrib4NuivARB_names, VertexAttrib4NuivARB_remap_index, 663 },
+    { IsProgramNV_names, IsProgramNV_remap_index, 592 },
+    { ProgramEnvParameter4dARB_names, ProgramEnvParameter4dARB_remap_index, 668 },
+    { VertexAttrib1dARB_names, VertexAttrib1dARB_remap_index, 603 },
+    { VertexAttrib3svARB_names, VertexAttrib3svARB_remap_index, 620 },
+    { GetVertexAttribdvARB_names, GetVertexAttribdvARB_remap_index, 588 },
+    { VertexAttrib4dvARB_names, VertexAttrib4dvARB_remap_index, 622 },
+    { VertexAttribPointerARB_names, VertexAttribPointerARB_remap_index, 664 },
+    { VertexAttrib4NsvARB_names, VertexAttrib4NsvARB_remap_index, 660 },
+    { VertexAttrib3fvARB_names, VertexAttrib3fvARB_remap_index, 618 },
+    { VertexAttrib4NubARB_names, VertexAttrib4NubARB_remap_index, 627 },
+    { GetProgramEnvParameterfvARB_names, GetProgramEnvParameterfvARB_remap_index, 677 },
+    { ProgramLocalParameter4fvARB_names, ProgramLocalParameter4fvARB_remap_index, 675 },
+    { DeleteProgramsNV_names, DeleteProgramsNV_remap_index, 580 },
+    { GetVertexAttribPointervNV_names, GetVertexAttribPointervNV_remap_index, 591 },
+    { VertexAttrib4dARB_names, VertexAttrib4dARB_remap_index, 621 },
+    { GetProgramLocalParameterdvARB_names, GetProgramLocalParameterdvARB_remap_index, 678 },
+    { GetProgramivARB_names, GetProgramivARB_remap_index, 680 },
+    { VertexAttrib3sARB_names, VertexAttrib3sARB_remap_index, 619 },
+    { ProgramStringARB_names, ProgramStringARB_remap_index, 667 },
+    { ProgramLocalParameter4fARB_names, ProgramLocalParameter4fARB_remap_index, 674 },
+    { EnableVertexAttribArrayARB_names, EnableVertexAttribArrayARB_remap_index, 665 },
+    { VertexAttrib4uivARB_names, VertexAttrib4uivARB_remap_index, 658 },
+    { BindProgramNV_names, BindProgramNV_remap_index, 579 },
+    { VertexAttrib4svARB_names, VertexAttrib4svARB_remap_index, 626 },
+    { VertexAttrib2svARB_names, VertexAttrib2svARB_remap_index, 614 },
+    { VertexAttrib4NubvARB_names, VertexAttrib4NubvARB_remap_index, 628 },
+    { GetProgramEnvParameterdvARB_names, GetProgramEnvParameterdvARB_remap_index, 676 },
+    { VertexAttrib2sARB_names, VertexAttrib2sARB_remap_index, 613 },
+    { VertexAttrib1fvARB_names, VertexAttrib1fvARB_remap_index, 606 },
+    { GenProgramsNV_names, GenProgramsNV_remap_index, 582 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_vertex_shader)
 static const struct dri_extension_function GL_ARB_vertex_shader_functions[] = {
-    { GetActiveAttribARB_names, 751 },
-    { GetAttribLocationARB_names, 752 },
-    { BindAttribLocationARB_names, 750 },
-    { NULL, 0 }
+    { GetActiveAttribARB_names, GetActiveAttribARB_remap_index, 751 },
+    { GetAttribLocationARB_names, GetAttribLocationARB_remap_index, 752 },
+    { BindAttribLocationARB_names, BindAttribLocationARB_remap_index, 750 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ARB_window_pos)
 static const struct dri_extension_function GL_ARB_window_pos_functions[] = {
-    { WindowPos3fMESA_names, 523 },
-    { WindowPos2dvMESA_names, 514 },
-    { WindowPos2svMESA_names, 520 },
-    { WindowPos3dMESA_names, 521 },
-    { WindowPos2fvMESA_names, 516 },
-    { WindowPos2dMESA_names, 513 },
-    { WindowPos3dvMESA_names, 522 },
-    { WindowPos3fvMESA_names, 524 },
-    { WindowPos2iMESA_names, 517 },
-    { WindowPos3sMESA_names, 527 },
-    { WindowPos2ivMESA_names, 518 },
-    { WindowPos2sMESA_names, 519 },
-    { WindowPos3iMESA_names, 525 },
-    { WindowPos3ivMESA_names, 526 },
-    { WindowPos3svMESA_names, 528 },
-    { WindowPos2fMESA_names, 515 },
-    { NULL, 0 }
+    { WindowPos3fMESA_names, WindowPos3fMESA_remap_index, 523 },
+    { WindowPos2dvMESA_names, WindowPos2dvMESA_remap_index, 514 },
+    { WindowPos2svMESA_names, WindowPos2svMESA_remap_index, 520 },
+    { WindowPos3dMESA_names, WindowPos3dMESA_remap_index, 521 },
+    { WindowPos2fvMESA_names, WindowPos2fvMESA_remap_index, 516 },
+    { WindowPos2dMESA_names, WindowPos2dMESA_remap_index, 513 },
+    { WindowPos3dvMESA_names, WindowPos3dvMESA_remap_index, 522 },
+    { WindowPos3fvMESA_names, WindowPos3fvMESA_remap_index, 524 },
+    { WindowPos2iMESA_names, WindowPos2iMESA_remap_index, 517 },
+    { WindowPos3sMESA_names, WindowPos3sMESA_remap_index, 527 },
+    { WindowPos2ivMESA_names, WindowPos2ivMESA_remap_index, 518 },
+    { WindowPos2sMESA_names, WindowPos2sMESA_remap_index, 519 },
+    { WindowPos3iMESA_names, WindowPos3iMESA_remap_index, 525 },
+    { WindowPos3ivMESA_names, WindowPos3ivMESA_remap_index, 526 },
+    { WindowPos3svMESA_names, WindowPos3svMESA_remap_index, 528 },
+    { WindowPos2fMESA_names, WindowPos2fMESA_remap_index, 515 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ATI_blend_equation_separate)
 static const struct dri_extension_function GL_ATI_blend_equation_separate_functions[] = {
-    { BlendEquationSeparateEXT_names, 710 },
-    { NULL, 0 }
+    { BlendEquationSeparateEXT_names, BlendEquationSeparateEXT_remap_index, 710 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ATI_draw_buffers)
 static const struct dri_extension_function GL_ATI_draw_buffers_functions[] = {
-    { DrawBuffersARB_names, 413 },
-    { NULL, 0 }
+    { DrawBuffersARB_names, DrawBuffersARB_remap_index, 413 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_ATI_fragment_shader)
 static const struct dri_extension_function GL_ATI_fragment_shader_functions[] = {
-    { ColorFragmentOp3ATI_names, 791 },
-    { ColorFragmentOp2ATI_names, 790 },
-    { DeleteFragmentShaderATI_names, 784 },
-    { SetFragmentShaderConstantATI_names, 795 },
-    { SampleMapATI_names, 788 },
-    { AlphaFragmentOp2ATI_names, 793 },
-    { AlphaFragmentOp1ATI_names, 792 },
-    { ColorFragmentOp1ATI_names, 789 },
-    { AlphaFragmentOp3ATI_names, 794 },
-    { PassTexCoordATI_names, 787 },
-    { BeginFragmentShaderATI_names, 785 },
-    { BindFragmentShaderATI_names, 783 },
-    { GenFragmentShadersATI_names, 782 },
-    { EndFragmentShaderATI_names, 786 },
-    { NULL, 0 }
+    { ColorFragmentOp3ATI_names, ColorFragmentOp3ATI_remap_index, 791 },
+    { ColorFragmentOp2ATI_names, ColorFragmentOp2ATI_remap_index, 790 },
+    { DeleteFragmentShaderATI_names, DeleteFragmentShaderATI_remap_index, 784 },
+    { SetFragmentShaderConstantATI_names, SetFragmentShaderConstantATI_remap_index, 795 },
+    { SampleMapATI_names, SampleMapATI_remap_index, 788 },
+    { AlphaFragmentOp2ATI_names, AlphaFragmentOp2ATI_remap_index, 793 },
+    { AlphaFragmentOp1ATI_names, AlphaFragmentOp1ATI_remap_index, 792 },
+    { ColorFragmentOp1ATI_names, ColorFragmentOp1ATI_remap_index, 789 },
+    { AlphaFragmentOp3ATI_names, AlphaFragmentOp3ATI_remap_index, 794 },
+    { PassTexCoordATI_names, PassTexCoordATI_remap_index, 787 },
+    { BeginFragmentShaderATI_names, BeginFragmentShaderATI_remap_index, 785 },
+    { BindFragmentShaderATI_names, BindFragmentShaderATI_remap_index, 783 },
+    { GenFragmentShadersATI_names, GenFragmentShadersATI_remap_index, 782 },
+    { EndFragmentShaderATI_names, EndFragmentShaderATI_remap_index, 786 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_blend_color)
 static const struct dri_extension_function GL_EXT_blend_color_functions[] = {
-    { BlendColor_names, 336 },
-    { NULL, 0 }
+    { BlendColor_names, -1, 336 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_blend_equation_separate)
 static const struct dri_extension_function GL_EXT_blend_equation_separate_functions[] = {
-    { BlendEquationSeparateEXT_names, 710 },
-    { NULL, 0 }
+    { BlendEquationSeparateEXT_names, BlendEquationSeparateEXT_remap_index, 710 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_blend_func_separate)
 static const struct dri_extension_function GL_EXT_blend_func_separate_functions[] = {
-    { BlendFuncSeparateEXT_names, 537 },
-    { NULL, 0 }
+    { BlendFuncSeparateEXT_names, BlendFuncSeparateEXT_remap_index, 537 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_blend_minmax)
 static const struct dri_extension_function GL_EXT_blend_minmax_functions[] = {
-    { BlendEquation_names, 337 },
-    { NULL, 0 }
+    { BlendEquation_names, -1, 337 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_color_subtable)
 static const struct dri_extension_function GL_EXT_color_subtable_functions[] = {
-    { ColorSubTable_names, 346 },
-    { CopyColorSubTable_names, 347 },
-    { NULL, 0 }
+    { ColorSubTable_names, -1, 346 },
+    { CopyColorSubTable_names, -1, 347 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_compiled_vertex_array)
 static const struct dri_extension_function GL_EXT_compiled_vertex_array_functions[] = {
-    { UnlockArraysEXT_names, 541 },
-    { LockArraysEXT_names, 540 },
-    { NULL, 0 }
+    { UnlockArraysEXT_names, UnlockArraysEXT_remap_index, 541 },
+    { LockArraysEXT_names, LockArraysEXT_remap_index, 540 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_convolution)
 static const struct dri_extension_function GL_EXT_convolution_functions[] = {
-    { ConvolutionFilter1D_names, 348 },
-    { CopyConvolutionFilter1D_names, 354 },
-    { ConvolutionFilter2D_names, 349 },
-    { ConvolutionParameteriv_names, 353 },
-    { ConvolutionParameterfv_names, 351 },
-    { GetSeparableFilterEXT_names, 426 },
-    { GetConvolutionFilterEXT_names, 423 },
-    { GetConvolutionParameterfvEXT_names, 424 },
-    { SeparableFilter2D_names, 360 },
-    { ConvolutionParameteri_names, 352 },
-    { ConvolutionParameterf_names, 350 },
-    { GetConvolutionParameterivEXT_names, 425 },
-    { CopyConvolutionFilter2D_names, 355 },
-    { NULL, 0 }
+    { ConvolutionFilter1D_names, -1, 348 },
+    { CopyConvolutionFilter1D_names, -1, 354 },
+    { ConvolutionFilter2D_names, -1, 349 },
+    { ConvolutionParameteriv_names, -1, 353 },
+    { ConvolutionParameterfv_names, -1, 351 },
+    { GetSeparableFilterEXT_names, GetSeparableFilterEXT_remap_index, 426 },
+    { GetConvolutionFilterEXT_names, GetConvolutionFilterEXT_remap_index, 423 },
+    { GetConvolutionParameterfvEXT_names, GetConvolutionParameterfvEXT_remap_index, 424 },
+    { SeparableFilter2D_names, -1, 360 },
+    { ConvolutionParameteri_names, -1, 352 },
+    { ConvolutionParameterf_names, -1, 350 },
+    { GetConvolutionParameterivEXT_names, GetConvolutionParameterivEXT_remap_index, 425 },
+    { CopyConvolutionFilter2D_names, -1, 355 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_coordinate_frame)
 static const struct dri_extension_function GL_EXT_coordinate_frame_functions[] = {
-    { Binormal3fEXT_names, -1 },
-    { TangentPointerEXT_names, -1 },
-    { Binormal3ivEXT_names, -1 },
-    { Tangent3sEXT_names, -1 },
-    { Tangent3fvEXT_names, -1 },
-    { Tangent3dvEXT_names, -1 },
-    { Binormal3bvEXT_names, -1 },
-    { Binormal3dEXT_names, -1 },
-    { Tangent3fEXT_names, -1 },
-    { Binormal3sEXT_names, -1 },
-    { Tangent3ivEXT_names, -1 },
-    { Tangent3dEXT_names, -1 },
-    { Binormal3svEXT_names, -1 },
-    { Binormal3dvEXT_names, -1 },
-    { Tangent3iEXT_names, -1 },
-    { Tangent3bvEXT_names, -1 },
-    { Binormal3fvEXT_names, -1 },
-    { Tangent3bEXT_names, -1 },
-    { BinormalPointerEXT_names, -1 },
-    { Tangent3svEXT_names, -1 },
-    { Binormal3bEXT_names, -1 },
-    { Binormal3iEXT_names, -1 },
-    { NULL, 0 }
+    { Binormal3fEXT_names, Binormal3fEXT_remap_index, -1 },
+    { TangentPointerEXT_names, TangentPointerEXT_remap_index, -1 },
+    { Binormal3ivEXT_names, Binormal3ivEXT_remap_index, -1 },
+    { Tangent3sEXT_names, Tangent3sEXT_remap_index, -1 },
+    { Tangent3fvEXT_names, Tangent3fvEXT_remap_index, -1 },
+    { Tangent3dvEXT_names, Tangent3dvEXT_remap_index, -1 },
+    { Binormal3bvEXT_names, Binormal3bvEXT_remap_index, -1 },
+    { Binormal3dEXT_names, Binormal3dEXT_remap_index, -1 },
+    { Tangent3fEXT_names, Tangent3fEXT_remap_index, -1 },
+    { Binormal3sEXT_names, Binormal3sEXT_remap_index, -1 },
+    { Tangent3ivEXT_names, Tangent3ivEXT_remap_index, -1 },
+    { Tangent3dEXT_names, Tangent3dEXT_remap_index, -1 },
+    { Binormal3svEXT_names, Binormal3svEXT_remap_index, -1 },
+    { Binormal3dvEXT_names, Binormal3dvEXT_remap_index, -1 },
+    { Tangent3iEXT_names, Tangent3iEXT_remap_index, -1 },
+    { Tangent3bvEXT_names, Tangent3bvEXT_remap_index, -1 },
+    { Binormal3fvEXT_names, Binormal3fvEXT_remap_index, -1 },
+    { Tangent3bEXT_names, Tangent3bEXT_remap_index, -1 },
+    { BinormalPointerEXT_names, BinormalPointerEXT_remap_index, -1 },
+    { Tangent3svEXT_names, Tangent3svEXT_remap_index, -1 },
+    { Binormal3bEXT_names, Binormal3bEXT_remap_index, -1 },
+    { Binormal3iEXT_names, Binormal3iEXT_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_copy_texture)
 static const struct dri_extension_function GL_EXT_copy_texture_functions[] = {
-    { CopyTexSubImage3D_names, 373 },
-    { CopyTexImage2D_names, 324 },
-    { CopyTexImage1D_names, 323 },
-    { CopyTexSubImage2D_names, 326 },
-    { CopyTexSubImage1D_names, 325 },
-    { NULL, 0 }
+    { CopyTexSubImage3D_names, -1, 373 },
+    { CopyTexImage2D_names, -1, 324 },
+    { CopyTexImage1D_names, -1, 323 },
+    { CopyTexSubImage2D_names, -1, 326 },
+    { CopyTexSubImage1D_names, -1, 325 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_cull_vertex)
 static const struct dri_extension_function GL_EXT_cull_vertex_functions[] = {
-    { CullParameterdvEXT_names, 542 },
-    { CullParameterfvEXT_names, 543 },
-    { NULL, 0 }
+    { CullParameterdvEXT_names, CullParameterdvEXT_remap_index, 542 },
+    { CullParameterfvEXT_names, CullParameterfvEXT_remap_index, 543 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_depth_bounds_test)
 static const struct dri_extension_function GL_EXT_depth_bounds_test_functions[] = {
-    { DepthBoundsEXT_names, 699 },
-    { NULL, 0 }
+    { DepthBoundsEXT_names, DepthBoundsEXT_remap_index, 699 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_draw_range_elements)
 static const struct dri_extension_function GL_EXT_draw_range_elements_functions[] = {
-    { DrawRangeElements_names, 338 },
-    { NULL, 0 }
+    { DrawRangeElements_names, -1, 338 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_fog_coord)
 static const struct dri_extension_function GL_EXT_fog_coord_functions[] = {
-    { FogCoorddEXT_names, 547 },
-    { FogCoordfEXT_names, 545 },
-    { FogCoordPointerEXT_names, 549 },
-    { FogCoordfvEXT_names, 546 },
-    { FogCoorddvEXT_names, 548 },
-    { NULL, 0 }
+    { FogCoorddEXT_names, FogCoorddEXT_remap_index, 547 },
+    { FogCoordfEXT_names, FogCoordfEXT_remap_index, 545 },
+    { FogCoordPointerEXT_names, FogCoordPointerEXT_remap_index, 549 },
+    { FogCoordfvEXT_names, FogCoordfvEXT_remap_index, 546 },
+    { FogCoorddvEXT_names, FogCoorddvEXT_remap_index, 548 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_framebuffer_object)
 static const struct dri_extension_function GL_EXT_framebuffer_object_functions[] = {
-    { GenerateMipmapEXT_names, 812 },
-    { IsRenderbufferEXT_names, 796 },
-    { RenderbufferStorageEXT_names, 800 },
-    { CheckFramebufferStatusEXT_names, 806 },
-    { DeleteRenderbuffersEXT_names, 798 },
-    { FramebufferTexture3DEXT_names, 809 },
-    { FramebufferRenderbufferEXT_names, 810 },
-    { FramebufferTexture1DEXT_names, 807 },
-    { BindFramebufferEXT_names, 803 },
-    { GenRenderbuffersEXT_names, 799 },
-    { IsFramebufferEXT_names, 802 },
-    { FramebufferTexture2DEXT_names, 808 },
-    { GetFramebufferAttachmentParameterivEXT_names, 811 },
-    { DeleteFramebuffersEXT_names, 804 },
-    { GenFramebuffersEXT_names, 805 },
-    { BindRenderbufferEXT_names, 797 },
-    { GetRenderbufferParameterivEXT_names, 801 },
-    { NULL, 0 }
+    { GenerateMipmapEXT_names, GenerateMipmapEXT_remap_index, 812 },
+    { IsRenderbufferEXT_names, IsRenderbufferEXT_remap_index, 796 },
+    { RenderbufferStorageEXT_names, RenderbufferStorageEXT_remap_index, 800 },
+    { CheckFramebufferStatusEXT_names, CheckFramebufferStatusEXT_remap_index, 806 },
+    { DeleteRenderbuffersEXT_names, DeleteRenderbuffersEXT_remap_index, 798 },
+    { FramebufferTexture3DEXT_names, FramebufferTexture3DEXT_remap_index, 809 },
+    { FramebufferRenderbufferEXT_names, FramebufferRenderbufferEXT_remap_index, 810 },
+    { FramebufferTexture1DEXT_names, FramebufferTexture1DEXT_remap_index, 807 },
+    { BindFramebufferEXT_names, BindFramebufferEXT_remap_index, 803 },
+    { GenRenderbuffersEXT_names, GenRenderbuffersEXT_remap_index, 799 },
+    { IsFramebufferEXT_names, IsFramebufferEXT_remap_index, 802 },
+    { FramebufferTexture2DEXT_names, FramebufferTexture2DEXT_remap_index, 808 },
+    { GetFramebufferAttachmentParameterivEXT_names, GetFramebufferAttachmentParameterivEXT_remap_index, 811 },
+    { DeleteFramebuffersEXT_names, DeleteFramebuffersEXT_remap_index, 804 },
+    { GenFramebuffersEXT_names, GenFramebuffersEXT_remap_index, 805 },
+    { BindRenderbufferEXT_names, BindRenderbufferEXT_remap_index, 797 },
+    { GetRenderbufferParameterivEXT_names, GetRenderbufferParameterivEXT_remap_index, 801 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_histogram)
 static const struct dri_extension_function GL_EXT_histogram_functions[] = {
-    { Histogram_names, 367 },
-    { GetHistogramParameterivEXT_names, 419 },
-    { ResetHistogram_names, 369 },
-    { GetMinmaxEXT_names, 420 },
-    { GetHistogramParameterfvEXT_names, 418 },
-    { GetHistogramEXT_names, 417 },
-    { GetMinmaxParameterfvEXT_names, 421 },
-    { ResetMinmax_names, 370 },
-    { GetMinmaxParameterivEXT_names, 422 },
-    { Minmax_names, 368 },
-    { NULL, 0 }
+    { Histogram_names, -1, 367 },
+    { GetHistogramParameterivEXT_names, GetHistogramParameterivEXT_remap_index, 419 },
+    { ResetHistogram_names, -1, 369 },
+    { GetMinmaxEXT_names, GetMinmaxEXT_remap_index, 420 },
+    { GetHistogramParameterfvEXT_names, GetHistogramParameterfvEXT_remap_index, 418 },
+    { GetHistogramEXT_names, GetHistogramEXT_remap_index, 417 },
+    { GetMinmaxParameterfvEXT_names, GetMinmaxParameterfvEXT_remap_index, 421 },
+    { ResetMinmax_names, -1, 370 },
+    { GetMinmaxParameterivEXT_names, GetMinmaxParameterivEXT_remap_index, 422 },
+    { Minmax_names, -1, 368 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_index_func)
 static const struct dri_extension_function GL_EXT_index_func_functions[] = {
-    { IndexFuncEXT_names, 539 },
-    { NULL, 0 }
+    { IndexFuncEXT_names, IndexFuncEXT_remap_index, 539 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_index_material)
 static const struct dri_extension_function GL_EXT_index_material_functions[] = {
-    { IndexMaterialEXT_names, 538 },
-    { NULL, 0 }
+    { IndexMaterialEXT_names, IndexMaterialEXT_remap_index, 538 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_light_texture)
 static const struct dri_extension_function GL_EXT_light_texture_functions[] = {
-    { ApplyTextureEXT_names, -1 },
-    { TextureMaterialEXT_names, -1 },
-    { TextureLightEXT_names, -1 },
-    { NULL, 0 }
+    { ApplyTextureEXT_names, ApplyTextureEXT_remap_index, -1 },
+    { TextureMaterialEXT_names, TextureMaterialEXT_remap_index, -1 },
+    { TextureLightEXT_names, TextureLightEXT_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_multi_draw_arrays)
 static const struct dri_extension_function GL_EXT_multi_draw_arrays_functions[] = {
-    { MultiDrawElementsEXT_names, 645 },
-    { MultiDrawArraysEXT_names, 644 },
-    { NULL, 0 }
+    { MultiDrawElementsEXT_names, MultiDrawElementsEXT_remap_index, 645 },
+    { MultiDrawArraysEXT_names, MultiDrawArraysEXT_remap_index, 644 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_multisample)
 static const struct dri_extension_function GL_EXT_multisample_functions[] = {
-    { SampleMaskSGIS_names, 446 },
-    { SamplePatternSGIS_names, 447 },
-    { NULL, 0 }
+    { SampleMaskSGIS_names, SampleMaskSGIS_remap_index, 446 },
+    { SamplePatternSGIS_names, SamplePatternSGIS_remap_index, 447 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_paletted_texture)
 static const struct dri_extension_function GL_EXT_paletted_texture_functions[] = {
-    { GetColorTableParameterivEXT_names, 551 },
-    { GetColorTableEXT_names, 550 },
-    { ColorTable_names, 339 },
-    { GetColorTableParameterfvEXT_names, 552 },
-    { NULL, 0 }
+    { GetColorTableParameterivEXT_names, GetColorTableParameterivEXT_remap_index, 551 },
+    { GetColorTableEXT_names, GetColorTableEXT_remap_index, 550 },
+    { ColorTable_names, -1, 339 },
+    { GetColorTableParameterfvEXT_names, GetColorTableParameterfvEXT_remap_index, 552 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_pixel_transform)
 static const struct dri_extension_function GL_EXT_pixel_transform_functions[] = {
-    { PixelTransformParameterfvEXT_names, -1 },
-    { PixelTransformParameteriEXT_names, -1 },
-    { PixelTransformParameterfEXT_names, -1 },
-    { PixelTransformParameterivEXT_names, -1 },
-    { NULL, 0 }
+    { PixelTransformParameterfvEXT_names, PixelTransformParameterfvEXT_remap_index, -1 },
+    { PixelTransformParameteriEXT_names, PixelTransformParameteriEXT_remap_index, -1 },
+    { PixelTransformParameterfEXT_names, PixelTransformParameterfEXT_remap_index, -1 },
+    { PixelTransformParameterivEXT_names, PixelTransformParameterivEXT_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_point_parameters)
 static const struct dri_extension_function GL_EXT_point_parameters_functions[] = {
-    { PointParameterfEXT_names, 458 },
-    { PointParameterfvEXT_names, 459 },
-    { NULL, 0 }
+    { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 },
+    { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_polygon_offset)
 static const struct dri_extension_function GL_EXT_polygon_offset_functions[] = {
-    { PolygonOffsetEXT_names, 414 },
-    { NULL, 0 }
+    { PolygonOffsetEXT_names, PolygonOffsetEXT_remap_index, 414 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_secondary_color)
 static const struct dri_extension_function GL_EXT_secondary_color_functions[] = {
-    { SecondaryColor3iEXT_names, 567 },
-    { SecondaryColor3bEXT_names, 561 },
-    { SecondaryColor3bvEXT_names, 562 },
-    { SecondaryColor3sEXT_names, 569 },
-    { SecondaryColor3dEXT_names, 563 },
-    { SecondaryColorPointerEXT_names, 577 },
-    { SecondaryColor3uiEXT_names, 573 },
-    { SecondaryColor3usvEXT_names, 576 },
-    { SecondaryColor3ivEXT_names, 568 },
-    { SecondaryColor3fvEXT_names, 566 },
-    { SecondaryColor3ubvEXT_names, 572 },
-    { SecondaryColor3uivEXT_names, 574 },
-    { SecondaryColor3dvEXT_names, 564 },
-    { SecondaryColor3usEXT_names, 575 },
-    { SecondaryColor3ubEXT_names, 571 },
-    { SecondaryColor3fEXT_names, 565 },
-    { SecondaryColor3svEXT_names, 570 },
-    { NULL, 0 }
+    { SecondaryColor3iEXT_names, SecondaryColor3iEXT_remap_index, 567 },
+    { SecondaryColor3bEXT_names, SecondaryColor3bEXT_remap_index, 561 },
+    { SecondaryColor3bvEXT_names, SecondaryColor3bvEXT_remap_index, 562 },
+    { SecondaryColor3sEXT_names, SecondaryColor3sEXT_remap_index, 569 },
+    { SecondaryColor3dEXT_names, SecondaryColor3dEXT_remap_index, 563 },
+    { SecondaryColorPointerEXT_names, SecondaryColorPointerEXT_remap_index, 577 },
+    { SecondaryColor3uiEXT_names, SecondaryColor3uiEXT_remap_index, 573 },
+    { SecondaryColor3usvEXT_names, SecondaryColor3usvEXT_remap_index, 576 },
+    { SecondaryColor3ivEXT_names, SecondaryColor3ivEXT_remap_index, 568 },
+    { SecondaryColor3fvEXT_names, SecondaryColor3fvEXT_remap_index, 566 },
+    { SecondaryColor3ubvEXT_names, SecondaryColor3ubvEXT_remap_index, 572 },
+    { SecondaryColor3uivEXT_names, SecondaryColor3uivEXT_remap_index, 574 },
+    { SecondaryColor3dvEXT_names, SecondaryColor3dvEXT_remap_index, 564 },
+    { SecondaryColor3usEXT_names, SecondaryColor3usEXT_remap_index, 575 },
+    { SecondaryColor3ubEXT_names, SecondaryColor3ubEXT_remap_index, 571 },
+    { SecondaryColor3fEXT_names, SecondaryColor3fEXT_remap_index, 565 },
+    { SecondaryColor3svEXT_names, SecondaryColor3svEXT_remap_index, 570 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_stencil_two_side)
 static const struct dri_extension_function GL_EXT_stencil_two_side_functions[] = {
-    { ActiveStencilFaceEXT_names, 646 },
-    { NULL, 0 }
+    { ActiveStencilFaceEXT_names, ActiveStencilFaceEXT_remap_index, 646 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_subtexture)
 static const struct dri_extension_function GL_EXT_subtexture_functions[] = {
-    { TexSubImage1D_names, 332 },
-    { TexSubImage2D_names, 333 },
-    { NULL, 0 }
+    { TexSubImage1D_names, -1, 332 },
+    { TexSubImage2D_names, -1, 333 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_texture3D)
 static const struct dri_extension_function GL_EXT_texture3D_functions[] = {
-    { TexImage3D_names, 371 },
-    { TexSubImage3D_names, 372 },
-    { NULL, 0 }
+    { TexImage3D_names, -1, 371 },
+    { TexSubImage3D_names, -1, 372 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_texture_object)
 static const struct dri_extension_function GL_EXT_texture_object_functions[] = {
-    { PrioritizeTextures_names, 331 },
-    { DeleteTextures_names, 327 },
-    { GenTexturesEXT_names, 440 },
-    { AreTexturesResidentEXT_names, 439 },
-    { BindTexture_names, 307 },
-    { IsTextureEXT_names, 441 },
-    { NULL, 0 }
+    { PrioritizeTextures_names, -1, 331 },
+    { DeleteTextures_names, -1, 327 },
+    { GenTexturesEXT_names, GenTexturesEXT_remap_index, 440 },
+    { AreTexturesResidentEXT_names, AreTexturesResidentEXT_remap_index, 439 },
+    { BindTexture_names, -1, 307 },
+    { IsTextureEXT_names, IsTextureEXT_remap_index, 441 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_texture_perturb_normal)
 static const struct dri_extension_function GL_EXT_texture_perturb_normal_functions[] = {
-    { TextureNormalEXT_names, -1 },
-    { NULL, 0 }
+    { TextureNormalEXT_names, TextureNormalEXT_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_vertex_array)
 static const struct dri_extension_function GL_EXT_vertex_array_functions[] = {
-    { IndexPointerEXT_names, 450 },
-    { NormalPointerEXT_names, 451 },
-    { VertexPointerEXT_names, 453 },
-    { TexCoordPointerEXT_names, 452 },
-    { EdgeFlagPointerEXT_names, 449 },
-    { ArrayElement_names, 306 },
-    { ColorPointerEXT_names, 448 },
-    { GetPointerv_names, 329 },
-    { DrawArrays_names, 310 },
-    { NULL, 0 }
+    { IndexPointerEXT_names, IndexPointerEXT_remap_index, 450 },
+    { NormalPointerEXT_names, NormalPointerEXT_remap_index, 451 },
+    { VertexPointerEXT_names, VertexPointerEXT_remap_index, 453 },
+    { TexCoordPointerEXT_names, TexCoordPointerEXT_remap_index, 452 },
+    { EdgeFlagPointerEXT_names, EdgeFlagPointerEXT_remap_index, 449 },
+    { ArrayElement_names, -1, 306 },
+    { ColorPointerEXT_names, ColorPointerEXT_remap_index, 448 },
+    { GetPointerv_names, -1, 329 },
+    { DrawArrays_names, -1, 310 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_EXT_vertex_weighting)
 static const struct dri_extension_function GL_EXT_vertex_weighting_functions[] = {
-    { VertexWeightfvEXT_names, 495 },
-    { VertexWeightfEXT_names, 494 },
-    { VertexWeightPointerEXT_names, 496 },
-    { NULL, 0 }
+    { VertexWeightfvEXT_names, VertexWeightfvEXT_remap_index, 495 },
+    { VertexWeightfEXT_names, VertexWeightfEXT_remap_index, 494 },
+    { VertexWeightPointerEXT_names, VertexWeightPointerEXT_remap_index, 496 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_HP_image_transform)
 static const struct dri_extension_function GL_HP_image_transform_functions[] = {
-    { GetImageTransformParameterfvHP_names, -1 },
-    { ImageTransformParameterfHP_names, -1 },
-    { ImageTransformParameterfvHP_names, -1 },
-    { ImageTransformParameteriHP_names, -1 },
-    { GetImageTransformParameterivHP_names, -1 },
-    { ImageTransformParameterivHP_names, -1 },
-    { NULL, 0 }
+    { GetImageTransformParameterfvHP_names, GetImageTransformParameterfvHP_remap_index, -1 },
+    { ImageTransformParameterfHP_names, ImageTransformParameterfHP_remap_index, -1 },
+    { ImageTransformParameterfvHP_names, ImageTransformParameterfvHP_remap_index, -1 },
+    { ImageTransformParameteriHP_names, ImageTransformParameteriHP_remap_index, -1 },
+    { GetImageTransformParameterivHP_names, GetImageTransformParameterivHP_remap_index, -1 },
+    { ImageTransformParameterivHP_names, ImageTransformParameterivHP_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_IBM_multimode_draw_arrays)
 static const struct dri_extension_function GL_IBM_multimode_draw_arrays_functions[] = {
-    { MultiModeDrawArraysIBM_names, 708 },
-    { MultiModeDrawElementsIBM_names, 709 },
-    { NULL, 0 }
+    { MultiModeDrawArraysIBM_names, MultiModeDrawArraysIBM_remap_index, 708 },
+    { MultiModeDrawElementsIBM_names, MultiModeDrawElementsIBM_remap_index, 709 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_IBM_vertex_array_lists)
 static const struct dri_extension_function GL_IBM_vertex_array_lists_functions[] = {
-    { SecondaryColorPointerListIBM_names, -1 },
-    { NormalPointerListIBM_names, -1 },
-    { FogCoordPointerListIBM_names, -1 },
-    { VertexPointerListIBM_names, -1 },
-    { ColorPointerListIBM_names, -1 },
-    { TexCoordPointerListIBM_names, -1 },
-    { IndexPointerListIBM_names, -1 },
-    { EdgeFlagPointerListIBM_names, -1 },
-    { NULL, 0 }
+    { SecondaryColorPointerListIBM_names, SecondaryColorPointerListIBM_remap_index, -1 },
+    { NormalPointerListIBM_names, NormalPointerListIBM_remap_index, -1 },
+    { FogCoordPointerListIBM_names, FogCoordPointerListIBM_remap_index, -1 },
+    { VertexPointerListIBM_names, VertexPointerListIBM_remap_index, -1 },
+    { ColorPointerListIBM_names, ColorPointerListIBM_remap_index, -1 },
+    { TexCoordPointerListIBM_names, TexCoordPointerListIBM_remap_index, -1 },
+    { IndexPointerListIBM_names, IndexPointerListIBM_remap_index, -1 },
+    { EdgeFlagPointerListIBM_names, EdgeFlagPointerListIBM_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_INGR_blend_func_separate)
 static const struct dri_extension_function GL_INGR_blend_func_separate_functions[] = {
-    { BlendFuncSeparateEXT_names, 537 },
-    { NULL, 0 }
+    { BlendFuncSeparateEXT_names, BlendFuncSeparateEXT_remap_index, 537 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_INTEL_parallel_arrays)
 static const struct dri_extension_function GL_INTEL_parallel_arrays_functions[] = {
-    { VertexPointervINTEL_names, -1 },
-    { ColorPointervINTEL_names, -1 },
-    { NormalPointervINTEL_names, -1 },
-    { TexCoordPointervINTEL_names, -1 },
-    { NULL, 0 }
+    { VertexPointervINTEL_names, VertexPointervINTEL_remap_index, -1 },
+    { ColorPointervINTEL_names, ColorPointervINTEL_remap_index, -1 },
+    { NormalPointervINTEL_names, NormalPointervINTEL_remap_index, -1 },
+    { TexCoordPointervINTEL_names, TexCoordPointervINTEL_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_MESA_resize_buffers)
 static const struct dri_extension_function GL_MESA_resize_buffers_functions[] = {
-    { ResizeBuffersMESA_names, 512 },
-    { NULL, 0 }
+    { ResizeBuffersMESA_names, ResizeBuffersMESA_remap_index, 512 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_MESA_window_pos)
 static const struct dri_extension_function GL_MESA_window_pos_functions[] = {
-    { WindowPos3fMESA_names, 523 },
-    { WindowPos2dvMESA_names, 514 },
-    { WindowPos4svMESA_names, 536 },
-    { WindowPos2svMESA_names, 520 },
-    { WindowPos3dMESA_names, 521 },
-    { WindowPos2fvMESA_names, 516 },
-    { WindowPos4dMESA_names, 529 },
-    { WindowPos2dMESA_names, 513 },
-    { WindowPos4ivMESA_names, 534 },
-    { WindowPos4fMESA_names, 531 },
-    { WindowPos3dvMESA_names, 522 },
-    { WindowPos3fvMESA_names, 524 },
-    { WindowPos4dvMESA_names, 530 },
-    { WindowPos2iMESA_names, 517 },
-    { WindowPos3sMESA_names, 527 },
-    { WindowPos4sMESA_names, 535 },
-    { WindowPos2ivMESA_names, 518 },
-    { WindowPos2sMESA_names, 519 },
-    { WindowPos3iMESA_names, 525 },
-    { WindowPos3ivMESA_names, 526 },
-    { WindowPos4iMESA_names, 533 },
-    { WindowPos4fvMESA_names, 532 },
-    { WindowPos3svMESA_names, 528 },
-    { WindowPos2fMESA_names, 515 },
-    { NULL, 0 }
+    { WindowPos3fMESA_names, WindowPos3fMESA_remap_index, 523 },
+    { WindowPos2dvMESA_names, WindowPos2dvMESA_remap_index, 514 },
+    { WindowPos4svMESA_names, WindowPos4svMESA_remap_index, 536 },
+    { WindowPos2svMESA_names, WindowPos2svMESA_remap_index, 520 },
+    { WindowPos3dMESA_names, WindowPos3dMESA_remap_index, 521 },
+    { WindowPos2fvMESA_names, WindowPos2fvMESA_remap_index, 516 },
+    { WindowPos4dMESA_names, WindowPos4dMESA_remap_index, 529 },
+    { WindowPos2dMESA_names, WindowPos2dMESA_remap_index, 513 },
+    { WindowPos4ivMESA_names, WindowPos4ivMESA_remap_index, 534 },
+    { WindowPos4fMESA_names, WindowPos4fMESA_remap_index, 531 },
+    { WindowPos3dvMESA_names, WindowPos3dvMESA_remap_index, 522 },
+    { WindowPos3fvMESA_names, WindowPos3fvMESA_remap_index, 524 },
+    { WindowPos4dvMESA_names, WindowPos4dvMESA_remap_index, 530 },
+    { WindowPos2iMESA_names, WindowPos2iMESA_remap_index, 517 },
+    { WindowPos3sMESA_names, WindowPos3sMESA_remap_index, 527 },
+    { WindowPos4sMESA_names, WindowPos4sMESA_remap_index, 535 },
+    { WindowPos2ivMESA_names, WindowPos2ivMESA_remap_index, 518 },
+    { WindowPos2sMESA_names, WindowPos2sMESA_remap_index, 519 },
+    { WindowPos3iMESA_names, WindowPos3iMESA_remap_index, 525 },
+    { WindowPos3ivMESA_names, WindowPos3ivMESA_remap_index, 526 },
+    { WindowPos4iMESA_names, WindowPos4iMESA_remap_index, 533 },
+    { WindowPos4fvMESA_names, WindowPos4fvMESA_remap_index, 532 },
+    { WindowPos3svMESA_names, WindowPos3svMESA_remap_index, 528 },
+    { WindowPos2fMESA_names, WindowPos2fMESA_remap_index, 515 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_evaluators)
 static const struct dri_extension_function GL_NV_evaluators_functions[] = {
-    { GetMapAttribParameterivNV_names, -1 },
-    { MapControlPointsNV_names, -1 },
-    { MapParameterfvNV_names, -1 },
-    { EvalMapsNV_names, -1 },
-    { GetMapAttribParameterfvNV_names, -1 },
-    { MapParameterivNV_names, -1 },
-    { GetMapParameterivNV_names, -1 },
-    { GetMapParameterfvNV_names, -1 },
-    { GetMapControlPointsNV_names, -1 },
-    { NULL, 0 }
+    { GetMapAttribParameterivNV_names, GetMapAttribParameterivNV_remap_index, -1 },
+    { MapControlPointsNV_names, MapControlPointsNV_remap_index, -1 },
+    { MapParameterfvNV_names, MapParameterfvNV_remap_index, -1 },
+    { EvalMapsNV_names, EvalMapsNV_remap_index, -1 },
+    { GetMapAttribParameterfvNV_names, GetMapAttribParameterfvNV_remap_index, -1 },
+    { MapParameterivNV_names, MapParameterivNV_remap_index, -1 },
+    { GetMapParameterivNV_names, GetMapParameterivNV_remap_index, -1 },
+    { GetMapParameterfvNV_names, GetMapParameterfvNV_remap_index, -1 },
+    { GetMapControlPointsNV_names, GetMapControlPointsNV_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_fence)
 static const struct dri_extension_function GL_NV_fence_functions[] = {
-    { GenFencesNV_names, 648 },
-    { TestFenceNV_names, 650 },
-    { IsFenceNV_names, 649 },
-    { DeleteFencesNV_names, 647 },
-    { SetFenceNV_names, 653 },
-    { GetFenceivNV_names, 651 },
-    { FinishFenceNV_names, 652 },
-    { NULL, 0 }
+    { GenFencesNV_names, GenFencesNV_remap_index, 648 },
+    { TestFenceNV_names, TestFenceNV_remap_index, 650 },
+    { IsFenceNV_names, IsFenceNV_remap_index, 649 },
+    { DeleteFencesNV_names, DeleteFencesNV_remap_index, 647 },
+    { SetFenceNV_names, SetFenceNV_remap_index, 653 },
+    { GetFenceivNV_names, GetFenceivNV_remap_index, 651 },
+    { FinishFenceNV_names, FinishFenceNV_remap_index, 652 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_fragment_program)
 static const struct dri_extension_function GL_NV_fragment_program_functions[] = {
-    { GetProgramNamedParameterdvNV_names, 687 },
-    { GetProgramNamedParameterfvNV_names, 686 },
-    { ProgramNamedParameter4fNV_names, 682 },
-    { ProgramNamedParameter4fvNV_names, 684 },
-    { ProgramNamedParameter4dvNV_names, 685 },
-    { ProgramNamedParameter4dNV_names, 683 },
-    { NULL, 0 }
+    { GetProgramNamedParameterdvNV_names, GetProgramNamedParameterdvNV_remap_index, 687 },
+    { GetProgramNamedParameterfvNV_names, GetProgramNamedParameterfvNV_remap_index, 686 },
+    { ProgramNamedParameter4fNV_names, ProgramNamedParameter4fNV_remap_index, 682 },
+    { ProgramNamedParameter4fvNV_names, ProgramNamedParameter4fvNV_remap_index, 684 },
+    { ProgramNamedParameter4dvNV_names, ProgramNamedParameter4dvNV_remap_index, 685 },
+    { ProgramNamedParameter4dNV_names, ProgramNamedParameter4dNV_remap_index, 683 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_point_sprite)
 static const struct dri_extension_function GL_NV_point_sprite_functions[] = {
-    { PointParameteriNV_names, 642 },
-    { PointParameterivNV_names, 643 },
-    { NULL, 0 }
+    { PointParameteriNV_names, PointParameteriNV_remap_index, 642 },
+    { PointParameterivNV_names, PointParameterivNV_remap_index, 643 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_register_combiners)
 static const struct dri_extension_function GL_NV_register_combiners_functions[] = {
-    { CombinerParameterfvNV_names, 499 },
-    { GetCombinerOutputParameterfvNV_names, 508 },
-    { FinalCombinerInputNV_names, 505 },
-    { GetCombinerInputParameterfvNV_names, 506 },
-    { GetCombinerOutputParameterivNV_names, 509 },
-    { CombinerOutputNV_names, 504 },
-    { CombinerParameteriNV_names, 502 },
-    { GetFinalCombinerInputParameterivNV_names, 511 },
-    { CombinerInputNV_names, 503 },
-    { CombinerParameterfNV_names, 500 },
-    { GetFinalCombinerInputParameterfvNV_names, 510 },
-    { GetCombinerInputParameterivNV_names, 507 },
-    { CombinerParameterivNV_names, 501 },
-    { NULL, 0 }
+    { CombinerParameterfvNV_names, CombinerParameterfvNV_remap_index, 499 },
+    { GetCombinerOutputParameterfvNV_names, GetCombinerOutputParameterfvNV_remap_index, 508 },
+    { FinalCombinerInputNV_names, FinalCombinerInputNV_remap_index, 505 },
+    { GetCombinerInputParameterfvNV_names, GetCombinerInputParameterfvNV_remap_index, 506 },
+    { GetCombinerOutputParameterivNV_names, GetCombinerOutputParameterivNV_remap_index, 509 },
+    { CombinerOutputNV_names, CombinerOutputNV_remap_index, 504 },
+    { CombinerParameteriNV_names, CombinerParameteriNV_remap_index, 502 },
+    { GetFinalCombinerInputParameterivNV_names, GetFinalCombinerInputParameterivNV_remap_index, 511 },
+    { CombinerInputNV_names, CombinerInputNV_remap_index, 503 },
+    { CombinerParameterfNV_names, CombinerParameterfNV_remap_index, 500 },
+    { GetFinalCombinerInputParameterfvNV_names, GetFinalCombinerInputParameterfvNV_remap_index, 510 },
+    { GetCombinerInputParameterivNV_names, GetCombinerInputParameterivNV_remap_index, 507 },
+    { CombinerParameterivNV_names, CombinerParameterivNV_remap_index, 501 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_register_combiners2)
 static const struct dri_extension_function GL_NV_register_combiners2_functions[] = {
-    { CombinerStageParameterfvNV_names, -1 },
-    { GetCombinerStageParameterfvNV_names, -1 },
-    { NULL, 0 }
+    { CombinerStageParameterfvNV_names, CombinerStageParameterfvNV_remap_index, -1 },
+    { GetCombinerStageParameterfvNV_names, GetCombinerStageParameterfvNV_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_vertex_array_range)
 static const struct dri_extension_function GL_NV_vertex_array_range_functions[] = {
-    { FlushVertexArrayRangeNV_names, 497 },
-    { VertexArrayRangeNV_names, 498 },
-    { NULL, 0 }
+    { FlushVertexArrayRangeNV_names, FlushVertexArrayRangeNV_remap_index, 497 },
+    { VertexArrayRangeNV_names, VertexArrayRangeNV_remap_index, 498 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_NV_vertex_program)
 static const struct dri_extension_function GL_NV_vertex_program_functions[] = {
-    { ProgramParameter4fNV_names, 596 },
-    { VertexAttrib4ubvNV_names, 781 },
-    { VertexAttrib4svNV_names, 779 },
-    { VertexAttribs1dvNV_names, 629 },
-    { ProgramParameter4dvNV_names, 595 },
-    { VertexAttrib4fNV_names, 776 },
-    { VertexAttrib2dNV_names, 762 },
-    { VertexAttrib4ubNV_names, 780 },
-    { VertexAttribs3dvNV_names, 635 },
-    { VertexAttribs4fvNV_names, 639 },
-    { VertexAttrib2sNV_names, 766 },
-    { VertexAttribs3fvNV_names, 636 },
-    { ProgramParameter4dNV_names, 594 },
-    { LoadProgramNV_names, 593 },
-    { VertexAttrib4fvNV_names, 777 },
-    { VertexAttrib3fNV_names, 770 },
-    { VertexAttribs2dvNV_names, 632 },
-    { GetProgramParameterfvNV_names, 584 },
-    { VertexAttrib3dNV_names, 768 },
-    { VertexAttrib2fvNV_names, 765 },
-    { VertexAttrib2dvNV_names, 763 },
-    { VertexAttrib1dvNV_names, 757 },
-    { ProgramParameter4fvNV_names, 597 },
-    { VertexAttrib1svNV_names, 761 },
-    { VertexAttribs2svNV_names, 634 },
-    { GetVertexAttribivNV_names, 755 },
-    { GetVertexAttribfvNV_names, 754 },
-    { VertexAttrib2svNV_names, 767 },
-    { VertexAttribs1fvNV_names, 630 },
-    { IsProgramNV_names, 592 },
-    { VertexAttrib4sNV_names, 778 },
-    { VertexAttrib2fNV_names, 764 },
-    { RequestResidentProgramsNV_names, 600 },
-    { ExecuteProgramNV_names, 581 },
-    { VertexAttribPointerNV_names, 602 },
-    { TrackMatrixNV_names, 601 },
-    { GetProgramParameterdvNV_names, 583 },
-    { VertexAttrib3sNV_names, 772 },
-    { GetTrackMatrixivNV_names, 587 },
-    { VertexAttrib3svNV_names, 773 },
-    { ProgramParameters4fvNV_names, 599 },
-    { GetProgramivNV_names, 585 },
-    { GetVertexAttribdvNV_names, 753 },
-    { VertexAttrib3fvNV_names, 771 },
-    { VertexAttribs2fvNV_names, 633 },
-    { VertexAttrib1fvNV_names, 759 },
-    { DeleteProgramsNV_names, 580 },
-    { GetVertexAttribPointervNV_names, 591 },
-    { GetProgramStringNV_names, 586 },
-    { VertexAttribs4dvNV_names, 638 },
-    { ProgramParameters4dvNV_names, 598 },
-    { VertexAttrib1fNV_names, 758 },
-    { VertexAttrib4dNV_names, 774 },
-    { VertexAttribs4ubvNV_names, 641 },
-    { VertexAttribs3svNV_names, 637 },
-    { VertexAttrib1sNV_names, 760 },
-    { BindProgramNV_names, 579 },
-    { AreProgramsResidentNV_names, 578 },
-    { VertexAttrib3dvNV_names, 769 },
-    { VertexAttrib1dNV_names, 756 },
-    { VertexAttribs4svNV_names, 640 },
-    { VertexAttribs1svNV_names, 631 },
-    { GenProgramsNV_names, 582 },
-    { VertexAttrib4dvNV_names, 775 },
-    { NULL, 0 }
+    { ProgramParameter4fNV_names, ProgramParameter4fNV_remap_index, 596 },
+    { VertexAttrib4ubvNV_names, VertexAttrib4ubvNV_remap_index, 781 },
+    { VertexAttrib4svNV_names, VertexAttrib4svNV_remap_index, 779 },
+    { VertexAttribs1dvNV_names, VertexAttribs1dvNV_remap_index, 629 },
+    { ProgramParameter4dvNV_names, ProgramParameter4dvNV_remap_index, 595 },
+    { VertexAttrib4fNV_names, VertexAttrib4fNV_remap_index, 776 },
+    { VertexAttrib2dNV_names, VertexAttrib2dNV_remap_index, 762 },
+    { VertexAttrib4ubNV_names, VertexAttrib4ubNV_remap_index, 780 },
+    { VertexAttribs3dvNV_names, VertexAttribs3dvNV_remap_index, 635 },
+    { VertexAttribs4fvNV_names, VertexAttribs4fvNV_remap_index, 639 },
+    { VertexAttrib2sNV_names, VertexAttrib2sNV_remap_index, 766 },
+    { VertexAttribs3fvNV_names, VertexAttribs3fvNV_remap_index, 636 },
+    { ProgramParameter4dNV_names, ProgramParameter4dNV_remap_index, 594 },
+    { LoadProgramNV_names, LoadProgramNV_remap_index, 593 },
+    { VertexAttrib4fvNV_names, VertexAttrib4fvNV_remap_index, 777 },
+    { VertexAttrib3fNV_names, VertexAttrib3fNV_remap_index, 770 },
+    { VertexAttribs2dvNV_names, VertexAttribs2dvNV_remap_index, 632 },
+    { GetProgramParameterfvNV_names, GetProgramParameterfvNV_remap_index, 584 },
+    { VertexAttrib3dNV_names, VertexAttrib3dNV_remap_index, 768 },
+    { VertexAttrib2fvNV_names, VertexAttrib2fvNV_remap_index, 765 },
+    { VertexAttrib2dvNV_names, VertexAttrib2dvNV_remap_index, 763 },
+    { VertexAttrib1dvNV_names, VertexAttrib1dvNV_remap_index, 757 },
+    { ProgramParameter4fvNV_names, ProgramParameter4fvNV_remap_index, 597 },
+    { VertexAttrib1svNV_names, VertexAttrib1svNV_remap_index, 761 },
+    { VertexAttribs2svNV_names, VertexAttribs2svNV_remap_index, 634 },
+    { GetVertexAttribivNV_names, GetVertexAttribivNV_remap_index, 755 },
+    { GetVertexAttribfvNV_names, GetVertexAttribfvNV_remap_index, 754 },
+    { VertexAttrib2svNV_names, VertexAttrib2svNV_remap_index, 767 },
+    { VertexAttribs1fvNV_names, VertexAttribs1fvNV_remap_index, 630 },
+    { IsProgramNV_names, IsProgramNV_remap_index, 592 },
+    { VertexAttrib4sNV_names, VertexAttrib4sNV_remap_index, 778 },
+    { VertexAttrib2fNV_names, VertexAttrib2fNV_remap_index, 764 },
+    { RequestResidentProgramsNV_names, RequestResidentProgramsNV_remap_index, 600 },
+    { ExecuteProgramNV_names, ExecuteProgramNV_remap_index, 581 },
+    { VertexAttribPointerNV_names, VertexAttribPointerNV_remap_index, 602 },
+    { TrackMatrixNV_names, TrackMatrixNV_remap_index, 601 },
+    { GetProgramParameterdvNV_names, GetProgramParameterdvNV_remap_index, 583 },
+    { VertexAttrib3sNV_names, VertexAttrib3sNV_remap_index, 772 },
+    { GetTrackMatrixivNV_names, GetTrackMatrixivNV_remap_index, 587 },
+    { VertexAttrib3svNV_names, VertexAttrib3svNV_remap_index, 773 },
+    { ProgramParameters4fvNV_names, ProgramParameters4fvNV_remap_index, 599 },
+    { GetProgramivNV_names, GetProgramivNV_remap_index, 585 },
+    { GetVertexAttribdvNV_names, GetVertexAttribdvNV_remap_index, 753 },
+    { VertexAttrib3fvNV_names, VertexAttrib3fvNV_remap_index, 771 },
+    { VertexAttribs2fvNV_names, VertexAttribs2fvNV_remap_index, 633 },
+    { VertexAttrib1fvNV_names, VertexAttrib1fvNV_remap_index, 759 },
+    { DeleteProgramsNV_names, DeleteProgramsNV_remap_index, 580 },
+    { GetVertexAttribPointervNV_names, GetVertexAttribPointervNV_remap_index, 591 },
+    { GetProgramStringNV_names, GetProgramStringNV_remap_index, 586 },
+    { VertexAttribs4dvNV_names, VertexAttribs4dvNV_remap_index, 638 },
+    { ProgramParameters4dvNV_names, ProgramParameters4dvNV_remap_index, 598 },
+    { VertexAttrib1fNV_names, VertexAttrib1fNV_remap_index, 758 },
+    { VertexAttrib4dNV_names, VertexAttrib4dNV_remap_index, 774 },
+    { VertexAttribs4ubvNV_names, VertexAttribs4ubvNV_remap_index, 641 },
+    { VertexAttribs3svNV_names, VertexAttribs3svNV_remap_index, 637 },
+    { VertexAttrib1sNV_names, VertexAttrib1sNV_remap_index, 760 },
+    { BindProgramNV_names, BindProgramNV_remap_index, 579 },
+    { AreProgramsResidentNV_names, AreProgramsResidentNV_remap_index, 578 },
+    { VertexAttrib3dvNV_names, VertexAttrib3dvNV_remap_index, 769 },
+    { VertexAttrib1dNV_names, VertexAttrib1dNV_remap_index, 756 },
+    { VertexAttribs4svNV_names, VertexAttribs4svNV_remap_index, 640 },
+    { VertexAttribs1svNV_names, VertexAttribs1svNV_remap_index, 631 },
+    { GenProgramsNV_names, GenProgramsNV_remap_index, 582 },
+    { VertexAttrib4dvNV_names, VertexAttrib4dvNV_remap_index, 775 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_PGI_misc_hints)
 static const struct dri_extension_function GL_PGI_misc_hints_functions[] = {
-    { HintPGI_names, 544 },
-    { NULL, 0 }
+    { HintPGI_names, HintPGI_remap_index, 544 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_detail_texture)
 static const struct dri_extension_function GL_SGIS_detail_texture_functions[] = {
-    { GetDetailTexFuncSGIS_names, 443 },
-    { DetailTexFuncSGIS_names, 442 },
-    { NULL, 0 }
+    { GetDetailTexFuncSGIS_names, GetDetailTexFuncSGIS_remap_index, 443 },
+    { DetailTexFuncSGIS_names, DetailTexFuncSGIS_remap_index, 442 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_fog_function)
 static const struct dri_extension_function GL_SGIS_fog_function_functions[] = {
-    { FogFuncSGIS_names, -1 },
-    { GetFogFuncSGIS_names, -1 },
-    { NULL, 0 }
+    { FogFuncSGIS_names, FogFuncSGIS_remap_index, -1 },
+    { GetFogFuncSGIS_names, GetFogFuncSGIS_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_multisample)
 static const struct dri_extension_function GL_SGIS_multisample_functions[] = {
-    { SampleMaskSGIS_names, 446 },
-    { SamplePatternSGIS_names, 447 },
-    { NULL, 0 }
+    { SampleMaskSGIS_names, SampleMaskSGIS_remap_index, 446 },
+    { SamplePatternSGIS_names, SamplePatternSGIS_remap_index, 447 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_pixel_texture)
 static const struct dri_extension_function GL_SGIS_pixel_texture_functions[] = {
-    { PixelTexGenParameterfvSGIS_names, 434 },
-    { GetPixelTexGenParameterivSGIS_names, 435 },
-    { PixelTexGenParameteriSGIS_names, 431 },
-    { PixelTexGenParameterivSGIS_names, 432 },
-    { PixelTexGenParameterfSGIS_names, 433 },
-    { GetPixelTexGenParameterfvSGIS_names, 436 },
-    { NULL, 0 }
+    { PixelTexGenParameterfvSGIS_names, PixelTexGenParameterfvSGIS_remap_index, 434 },
+    { GetPixelTexGenParameterivSGIS_names, GetPixelTexGenParameterivSGIS_remap_index, 435 },
+    { PixelTexGenParameteriSGIS_names, PixelTexGenParameteriSGIS_remap_index, 431 },
+    { PixelTexGenParameterivSGIS_names, PixelTexGenParameterivSGIS_remap_index, 432 },
+    { PixelTexGenParameterfSGIS_names, PixelTexGenParameterfSGIS_remap_index, 433 },
+    { GetPixelTexGenParameterfvSGIS_names, GetPixelTexGenParameterfvSGIS_remap_index, 436 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_point_parameters)
 static const struct dri_extension_function GL_SGIS_point_parameters_functions[] = {
-    { PointParameterfEXT_names, 458 },
-    { PointParameterfvEXT_names, 459 },
-    { NULL, 0 }
+    { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 },
+    { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_sharpen_texture)
 static const struct dri_extension_function GL_SGIS_sharpen_texture_functions[] = {
-    { GetSharpenTexFuncSGIS_names, 445 },
-    { SharpenTexFuncSGIS_names, 444 },
-    { NULL, 0 }
+    { GetSharpenTexFuncSGIS_names, GetSharpenTexFuncSGIS_remap_index, 445 },
+    { SharpenTexFuncSGIS_names, SharpenTexFuncSGIS_remap_index, 444 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_texture4D)
 static const struct dri_extension_function GL_SGIS_texture4D_functions[] = {
-    { TexImage4DSGIS_names, 437 },
-    { TexSubImage4DSGIS_names, 438 },
-    { NULL, 0 }
+    { TexImage4DSGIS_names, TexImage4DSGIS_remap_index, 437 },
+    { TexSubImage4DSGIS_names, TexSubImage4DSGIS_remap_index, 438 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_texture_color_mask)
 static const struct dri_extension_function GL_SGIS_texture_color_mask_functions[] = {
-    { TextureColorMaskSGIS_names, -1 },
-    { NULL, 0 }
+    { TextureColorMaskSGIS_names, TextureColorMaskSGIS_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIS_texture_filter4)
 static const struct dri_extension_function GL_SGIS_texture_filter4_functions[] = {
-    { GetTexFilterFuncSGIS_names, 415 },
-    { TexFilterFuncSGIS_names, 416 },
-    { NULL, 0 }
+    { GetTexFilterFuncSGIS_names, GetTexFilterFuncSGIS_remap_index, 415 },
+    { TexFilterFuncSGIS_names, TexFilterFuncSGIS_remap_index, 416 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_async)
 static const struct dri_extension_function GL_SGIX_async_functions[] = {
-    { AsyncMarkerSGIX_names, -1 },
-    { FinishAsyncSGIX_names, -1 },
-    { PollAsyncSGIX_names, -1 },
-    { DeleteAsyncMarkersSGIX_names, -1 },
-    { IsAsyncMarkerSGIX_names, -1 },
-    { GenAsyncMarkersSGIX_names, -1 },
-    { NULL, 0 }
+    { AsyncMarkerSGIX_names, AsyncMarkerSGIX_remap_index, -1 },
+    { FinishAsyncSGIX_names, FinishAsyncSGIX_remap_index, -1 },
+    { PollAsyncSGIX_names, PollAsyncSGIX_remap_index, -1 },
+    { DeleteAsyncMarkersSGIX_names, DeleteAsyncMarkersSGIX_remap_index, -1 },
+    { IsAsyncMarkerSGIX_names, IsAsyncMarkerSGIX_remap_index, -1 },
+    { GenAsyncMarkersSGIX_names, GenAsyncMarkersSGIX_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_flush_raster)
 static const struct dri_extension_function GL_SGIX_flush_raster_functions[] = {
-    { FlushRasterSGIX_names, 469 },
-    { NULL, 0 }
+    { FlushRasterSGIX_names, FlushRasterSGIX_remap_index, 469 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_fragment_lighting)
 static const struct dri_extension_function GL_SGIX_fragment_lighting_functions[] = {
-    { FragmentMaterialfvSGIX_names, 486 },
-    { FragmentLightModelivSGIX_names, 484 },
-    { FragmentLightiSGIX_names, 479 },
-    { GetFragmentMaterialfvSGIX_names, 491 },
-    { FragmentMaterialfSGIX_names, 485 },
-    { GetFragmentLightivSGIX_names, 490 },
-    { FragmentLightModeliSGIX_names, 483 },
-    { FragmentLightivSGIX_names, 480 },
-    { GetFragmentMaterialivSGIX_names, 492 },
-    { FragmentLightModelfSGIX_names, 481 },
-    { FragmentColorMaterialSGIX_names, 476 },
-    { FragmentMaterialiSGIX_names, 487 },
-    { LightEnviSGIX_names, 493 },
-    { FragmentLightModelfvSGIX_names, 482 },
-    { FragmentLightfvSGIX_names, 478 },
-    { FragmentLightfSGIX_names, 477 },
-    { GetFragmentLightfvSGIX_names, 489 },
-    { FragmentMaterialivSGIX_names, 488 },
-    { NULL, 0 }
+    { FragmentMaterialfvSGIX_names, FragmentMaterialfvSGIX_remap_index, 486 },
+    { FragmentLightModelivSGIX_names, FragmentLightModelivSGIX_remap_index, 484 },
+    { FragmentLightiSGIX_names, FragmentLightiSGIX_remap_index, 479 },
+    { GetFragmentMaterialfvSGIX_names, GetFragmentMaterialfvSGIX_remap_index, 491 },
+    { FragmentMaterialfSGIX_names, FragmentMaterialfSGIX_remap_index, 485 },
+    { GetFragmentLightivSGIX_names, GetFragmentLightivSGIX_remap_index, 490 },
+    { FragmentLightModeliSGIX_names, FragmentLightModeliSGIX_remap_index, 483 },
+    { FragmentLightivSGIX_names, FragmentLightivSGIX_remap_index, 480 },
+    { GetFragmentMaterialivSGIX_names, GetFragmentMaterialivSGIX_remap_index, 492 },
+    { FragmentLightModelfSGIX_names, FragmentLightModelfSGIX_remap_index, 481 },
+    { FragmentColorMaterialSGIX_names, FragmentColorMaterialSGIX_remap_index, 476 },
+    { FragmentMaterialiSGIX_names, FragmentMaterialiSGIX_remap_index, 487 },
+    { LightEnviSGIX_names, LightEnviSGIX_remap_index, 493 },
+    { FragmentLightModelfvSGIX_names, FragmentLightModelfvSGIX_remap_index, 482 },
+    { FragmentLightfvSGIX_names, FragmentLightfvSGIX_remap_index, 478 },
+    { FragmentLightfSGIX_names, FragmentLightfSGIX_remap_index, 477 },
+    { GetFragmentLightfvSGIX_names, GetFragmentLightfvSGIX_remap_index, 489 },
+    { FragmentMaterialivSGIX_names, FragmentMaterialivSGIX_remap_index, 488 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_framezoom)
 static const struct dri_extension_function GL_SGIX_framezoom_functions[] = {
-    { FrameZoomSGIX_names, 466 },
-    { NULL, 0 }
+    { FrameZoomSGIX_names, FrameZoomSGIX_remap_index, 466 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_igloo_interface)
 static const struct dri_extension_function GL_SGIX_igloo_interface_functions[] = {
-    { IglooInterfaceSGIX_names, -1 },
-    { NULL, 0 }
+    { IglooInterfaceSGIX_names, IglooInterfaceSGIX_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_instruments)
 static const struct dri_extension_function GL_SGIX_instruments_functions[] = {
-    { ReadInstrumentsSGIX_names, 463 },
-    { GetInstrumentsSGIX_names, 460 },
-    { StartInstrumentsSGIX_names, 464 },
-    { StopInstrumentsSGIX_names, 465 },
-    { InstrumentsBufferSGIX_names, 461 },
-    { PollInstrumentsSGIX_names, 462 },
-    { NULL, 0 }
+    { ReadInstrumentsSGIX_names, ReadInstrumentsSGIX_remap_index, 463 },
+    { GetInstrumentsSGIX_names, GetInstrumentsSGIX_remap_index, 460 },
+    { StartInstrumentsSGIX_names, StartInstrumentsSGIX_remap_index, 464 },
+    { StopInstrumentsSGIX_names, StopInstrumentsSGIX_remap_index, 465 },
+    { InstrumentsBufferSGIX_names, InstrumentsBufferSGIX_remap_index, 461 },
+    { PollInstrumentsSGIX_names, PollInstrumentsSGIX_remap_index, 462 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_list_priority)
 static const struct dri_extension_function GL_SGIX_list_priority_functions[] = {
-    { ListParameterfSGIX_names, 472 },
-    { GetListParameterivSGIX_names, 471 },
-    { GetListParameterfvSGIX_names, 470 },
-    { ListParameteriSGIX_names, 474 },
-    { ListParameterfvSGIX_names, 473 },
-    { ListParameterivSGIX_names, 475 },
-    { NULL, 0 }
+    { ListParameterfSGIX_names, ListParameterfSGIX_remap_index, 472 },
+    { GetListParameterivSGIX_names, GetListParameterivSGIX_remap_index, 471 },
+    { GetListParameterfvSGIX_names, GetListParameterfvSGIX_remap_index, 470 },
+    { ListParameteriSGIX_names, ListParameteriSGIX_remap_index, 474 },
+    { ListParameterfvSGIX_names, ListParameterfvSGIX_remap_index, 473 },
+    { ListParameterivSGIX_names, ListParameterivSGIX_remap_index, 475 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_pixel_texture)
 static const struct dri_extension_function GL_SGIX_pixel_texture_functions[] = {
-    { PixelTexGenSGIX_names, 430 },
-    { NULL, 0 }
+    { PixelTexGenSGIX_names, PixelTexGenSGIX_remap_index, 430 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_polynomial_ffd)
 static const struct dri_extension_function GL_SGIX_polynomial_ffd_functions[] = {
-    { LoadIdentityDeformationMapSGIX_names, -1 },
-    { DeformationMap3dSGIX_names, -1 },
-    { DeformSGIX_names, -1 },
-    { DeformationMap3fSGIX_names, -1 },
-    { NULL, 0 }
+    { LoadIdentityDeformationMapSGIX_names, LoadIdentityDeformationMapSGIX_remap_index, -1 },
+    { DeformationMap3dSGIX_names, DeformationMap3dSGIX_remap_index, -1 },
+    { DeformSGIX_names, DeformSGIX_remap_index, -1 },
+    { DeformationMap3fSGIX_names, DeformationMap3fSGIX_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_reference_plane)
 static const struct dri_extension_function GL_SGIX_reference_plane_functions[] = {
-    { ReferencePlaneSGIX_names, 468 },
-    { NULL, 0 }
+    { ReferencePlaneSGIX_names, ReferencePlaneSGIX_remap_index, 468 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_sprite)
 static const struct dri_extension_function GL_SGIX_sprite_functions[] = {
-    { SpriteParameterfvSGIX_names, 455 },
-    { SpriteParameteriSGIX_names, 456 },
-    { SpriteParameterfSGIX_names, 454 },
-    { SpriteParameterivSGIX_names, 457 },
-    { NULL, 0 }
+    { SpriteParameterfvSGIX_names, SpriteParameterfvSGIX_remap_index, 455 },
+    { SpriteParameteriSGIX_names, SpriteParameteriSGIX_remap_index, 456 },
+    { SpriteParameterfSGIX_names, SpriteParameterfSGIX_remap_index, 454 },
+    { SpriteParameterivSGIX_names, SpriteParameterivSGIX_remap_index, 457 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGIX_tag_sample_buffer)
 static const struct dri_extension_function GL_SGIX_tag_sample_buffer_functions[] = {
-    { TagSampleBufferSGIX_names, 467 },
-    { NULL, 0 }
+    { TagSampleBufferSGIX_names, TagSampleBufferSGIX_remap_index, 467 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SGI_color_table)
 static const struct dri_extension_function GL_SGI_color_table_functions[] = {
-    { GetColorTableParameterfvSGI_names, 428 },
-    { ColorTableParameteriv_names, 341 },
-    { ColorTable_names, 339 },
-    { CopyColorTable_names, 342 },
-    { ColorTableParameterfv_names, 340 },
-    { GetColorTableParameterivSGI_names, 429 },
-    { GetColorTableSGI_names, 427 },
-    { NULL, 0 }
+    { GetColorTableParameterfvSGI_names, GetColorTableParameterfvSGI_remap_index, 428 },
+    { ColorTableParameteriv_names, -1, 341 },
+    { ColorTable_names, -1, 339 },
+    { CopyColorTable_names, -1, 342 },
+    { ColorTableParameterfv_names, -1, 340 },
+    { GetColorTableParameterivSGI_names, GetColorTableParameterivSGI_remap_index, 429 },
+    { GetColorTableSGI_names, GetColorTableSGI_remap_index, 427 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SUNX_constant_data)
 static const struct dri_extension_function GL_SUNX_constant_data_functions[] = {
-    { FinishTextureSUNX_names, -1 },
-    { NULL, 0 }
+    { FinishTextureSUNX_names, FinishTextureSUNX_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SUN_global_alpha)
 static const struct dri_extension_function GL_SUN_global_alpha_functions[] = {
-    { GlobalAlphaFactorubSUN_names, -1 },
-    { GlobalAlphaFactoriSUN_names, -1 },
-    { GlobalAlphaFactordSUN_names, -1 },
-    { GlobalAlphaFactoruiSUN_names, -1 },
-    { GlobalAlphaFactorbSUN_names, -1 },
-    { GlobalAlphaFactorfSUN_names, -1 },
-    { GlobalAlphaFactorusSUN_names, -1 },
-    { GlobalAlphaFactorsSUN_names, -1 },
-    { NULL, 0 }
+    { GlobalAlphaFactorubSUN_names, GlobalAlphaFactorubSUN_remap_index, -1 },
+    { GlobalAlphaFactoriSUN_names, GlobalAlphaFactoriSUN_remap_index, -1 },
+    { GlobalAlphaFactordSUN_names, GlobalAlphaFactordSUN_remap_index, -1 },
+    { GlobalAlphaFactoruiSUN_names, GlobalAlphaFactoruiSUN_remap_index, -1 },
+    { GlobalAlphaFactorbSUN_names, GlobalAlphaFactorbSUN_remap_index, -1 },
+    { GlobalAlphaFactorfSUN_names, GlobalAlphaFactorfSUN_remap_index, -1 },
+    { GlobalAlphaFactorusSUN_names, GlobalAlphaFactorusSUN_remap_index, -1 },
+    { GlobalAlphaFactorsSUN_names, GlobalAlphaFactorsSUN_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SUN_mesh_array)
 static const struct dri_extension_function GL_SUN_mesh_array_functions[] = {
-    { DrawMeshArraysSUN_names, -1 },
-    { NULL, 0 }
+    { DrawMeshArraysSUN_names, DrawMeshArraysSUN_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SUN_triangle_list)
 static const struct dri_extension_function GL_SUN_triangle_list_functions[] = {
-    { ReplacementCodeubSUN_names, -1 },
-    { ReplacementCodeubvSUN_names, -1 },
-    { ReplacementCodeuivSUN_names, -1 },
-    { ReplacementCodeusvSUN_names, -1 },
-    { ReplacementCodePointerSUN_names, -1 },
-    { ReplacementCodeusSUN_names, -1 },
-    { ReplacementCodeuiSUN_names, -1 },
-    { NULL, 0 }
+    { ReplacementCodeubSUN_names, ReplacementCodeubSUN_remap_index, -1 },
+    { ReplacementCodeubvSUN_names, ReplacementCodeubvSUN_remap_index, -1 },
+    { ReplacementCodeuivSUN_names, ReplacementCodeuivSUN_remap_index, -1 },
+    { ReplacementCodeusvSUN_names, ReplacementCodeusvSUN_remap_index, -1 },
+    { ReplacementCodePointerSUN_names, ReplacementCodePointerSUN_remap_index, -1 },
+    { ReplacementCodeusSUN_names, ReplacementCodeusSUN_remap_index, -1 },
+    { ReplacementCodeuiSUN_names, ReplacementCodeuiSUN_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_SUN_vertex)
 static const struct dri_extension_function GL_SUN_vertex_functions[] = {
-    { ReplacementCodeuiColor3fVertex3fvSUN_names, -1 },
-    { TexCoord4fColor4fNormal3fVertex4fvSUN_names, -1 },
-    { TexCoord2fColor4ubVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiTexCoord2fVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiNormal3fVertex3fSUN_names, -1 },
-    { Color4ubVertex3fvSUN_names, -1 },
-    { Color4ubVertex3fSUN_names, -1 },
-    { TexCoord2fVertex3fSUN_names, -1 },
-    { TexCoord2fColor4fNormal3fVertex3fSUN_names, -1 },
-    { TexCoord2fNormal3fVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_names, -1 },
-    { ReplacementCodeuiTexCoord2fVertex3fSUN_names, -1 },
-    { Color3fVertex3fSUN_names, -1 },
-    { ReplacementCodeuiNormal3fVertex3fvSUN_names, -1 },
-    { Color3fVertex3fvSUN_names, -1 },
-    { Color4fNormal3fVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiColor4fNormal3fVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_names, -1 },
-    { TexCoord2fColor3fVertex3fSUN_names, -1 },
-    { TexCoord4fColor4fNormal3fVertex4fSUN_names, -1 },
-    { Color4ubVertex2fvSUN_names, -1 },
-    { Normal3fVertex3fSUN_names, -1 },
-    { ReplacementCodeuiColor4fNormal3fVertex3fSUN_names, -1 },
-    { TexCoord2fNormal3fVertex3fSUN_names, -1 },
-    { TexCoord2fVertex3fvSUN_names, -1 },
-    { Color4ubVertex2fSUN_names, -1 },
-    { ReplacementCodeuiColor4ubVertex3fSUN_names, -1 },
-    { TexCoord2fColor4ubVertex3fSUN_names, -1 },
-    { Normal3fVertex3fvSUN_names, -1 },
-    { Color4fNormal3fVertex3fSUN_names, -1 },
-    { TexCoord2fColor4fNormal3fVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_names, -1 },
-    { ReplacementCodeuiColor4ubVertex3fvSUN_names, -1 },
-    { ReplacementCodeuiColor3fVertex3fSUN_names, -1 },
-    { TexCoord4fVertex4fSUN_names, -1 },
-    { TexCoord2fColor3fVertex3fvSUN_names, -1 },
-    { TexCoord4fVertex4fvSUN_names, -1 },
-    { ReplacementCodeuiVertex3fSUN_names, -1 },
-    { NULL, 0 }
+    { ReplacementCodeuiColor3fVertex3fvSUN_names, ReplacementCodeuiColor3fVertex3fvSUN_remap_index, -1 },
+    { TexCoord4fColor4fNormal3fVertex4fvSUN_names, TexCoord4fColor4fNormal3fVertex4fvSUN_remap_index, -1 },
+    { TexCoord2fColor4ubVertex3fvSUN_names, TexCoord2fColor4ubVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiVertex3fvSUN_names, ReplacementCodeuiVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiTexCoord2fVertex3fvSUN_names, ReplacementCodeuiTexCoord2fVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiNormal3fVertex3fSUN_names, ReplacementCodeuiNormal3fVertex3fSUN_remap_index, -1 },
+    { Color4ubVertex3fvSUN_names, Color4ubVertex3fvSUN_remap_index, -1 },
+    { Color4ubVertex3fSUN_names, Color4ubVertex3fSUN_remap_index, -1 },
+    { TexCoord2fVertex3fSUN_names, TexCoord2fVertex3fSUN_remap_index, -1 },
+    { TexCoord2fColor4fNormal3fVertex3fSUN_names, TexCoord2fColor4fNormal3fVertex3fSUN_remap_index, -1 },
+    { TexCoord2fNormal3fVertex3fvSUN_names, TexCoord2fNormal3fVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_names, ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_remap_index, -1 },
+    { ReplacementCodeuiTexCoord2fVertex3fSUN_names, ReplacementCodeuiTexCoord2fVertex3fSUN_remap_index, -1 },
+    { Color3fVertex3fSUN_names, Color3fVertex3fSUN_remap_index, -1 },
+    { ReplacementCodeuiNormal3fVertex3fvSUN_names, ReplacementCodeuiNormal3fVertex3fvSUN_remap_index, -1 },
+    { Color3fVertex3fvSUN_names, Color3fVertex3fvSUN_remap_index, -1 },
+    { Color4fNormal3fVertex3fvSUN_names, Color4fNormal3fVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_names, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiColor4fNormal3fVertex3fvSUN_names, ReplacementCodeuiColor4fNormal3fVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_names, ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_remap_index, -1 },
+    { TexCoord2fColor3fVertex3fSUN_names, TexCoord2fColor3fVertex3fSUN_remap_index, -1 },
+    { TexCoord4fColor4fNormal3fVertex4fSUN_names, TexCoord4fColor4fNormal3fVertex4fSUN_remap_index, -1 },
+    { Color4ubVertex2fvSUN_names, Color4ubVertex2fvSUN_remap_index, -1 },
+    { Normal3fVertex3fSUN_names, Normal3fVertex3fSUN_remap_index, -1 },
+    { ReplacementCodeuiColor4fNormal3fVertex3fSUN_names, ReplacementCodeuiColor4fNormal3fVertex3fSUN_remap_index, -1 },
+    { TexCoord2fNormal3fVertex3fSUN_names, TexCoord2fNormal3fVertex3fSUN_remap_index, -1 },
+    { TexCoord2fVertex3fvSUN_names, TexCoord2fVertex3fvSUN_remap_index, -1 },
+    { Color4ubVertex2fSUN_names, Color4ubVertex2fSUN_remap_index, -1 },
+    { ReplacementCodeuiColor4ubVertex3fSUN_names, ReplacementCodeuiColor4ubVertex3fSUN_remap_index, -1 },
+    { TexCoord2fColor4ubVertex3fSUN_names, TexCoord2fColor4ubVertex3fSUN_remap_index, -1 },
+    { Normal3fVertex3fvSUN_names, Normal3fVertex3fvSUN_remap_index, -1 },
+    { Color4fNormal3fVertex3fSUN_names, Color4fNormal3fVertex3fSUN_remap_index, -1 },
+    { TexCoord2fColor4fNormal3fVertex3fvSUN_names, TexCoord2fColor4fNormal3fVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_names, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_remap_index, -1 },
+    { ReplacementCodeuiColor4ubVertex3fvSUN_names, ReplacementCodeuiColor4ubVertex3fvSUN_remap_index, -1 },
+    { ReplacementCodeuiColor3fVertex3fSUN_names, ReplacementCodeuiColor3fVertex3fSUN_remap_index, -1 },
+    { TexCoord4fVertex4fSUN_names, TexCoord4fVertex4fSUN_remap_index, -1 },
+    { TexCoord2fColor3fVertex3fvSUN_names, TexCoord2fColor3fVertex3fvSUN_remap_index, -1 },
+    { TexCoord4fVertex4fvSUN_names, TexCoord4fVertex4fvSUN_remap_index, -1 },
+    { ReplacementCodeuiVertex3fSUN_names, ReplacementCodeuiVertex3fSUN_remap_index, -1 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_VERSION_1_3)
 static const struct dri_extension_function GL_VERSION_1_3_functions[] = {
-    { SampleCoverageARB_names, 412 },
-    { MultiTexCoord3sARB_names, 398 },
-    { ActiveTextureARB_names, 374 },
-    { CompressedTexSubImage2DARB_names, 558 },
-    { CompressedTexImage3DARB_names, 554 },
-    { MultiTexCoord1fvARB_names, 379 },
-    { MultTransposeMatrixdARB_names, 411 },
-    { CompressedTexImage1DARB_names, 556 },
-    { MultiTexCoord3dARB_names, 392 },
-    { MultiTexCoord2iARB_names, 388 },
-    { MultiTexCoord2svARB_names, 391 },
-    { MultiTexCoord2fARB_names, 386 },
-    { LoadTransposeMatrixdARB_names, 409 },
-    { MultiTexCoord3fvARB_names, 395 },
-    { MultiTexCoord4sARB_names, 406 },
-    { MultiTexCoord2dvARB_names, 385 },
-    { MultiTexCoord1svARB_names, 383 },
-    { MultiTexCoord3svARB_names, 399 },
-    { MultiTexCoord4iARB_names, 404 },
-    { MultiTexCoord3iARB_names, 396 },
-    { MultiTexCoord1dARB_names, 376 },
-    { MultiTexCoord3dvARB_names, 393 },
-    { MultiTexCoord3ivARB_names, 397 },
-    { MultiTexCoord2sARB_names, 390 },
-    { MultiTexCoord4ivARB_names, 405 },
-    { CompressedTexSubImage1DARB_names, 559 },
-    { ClientActiveTextureARB_names, 375 },
-    { CompressedTexSubImage3DARB_names, 557 },
-    { MultiTexCoord2dARB_names, 384 },
-    { MultiTexCoord4dvARB_names, 401 },
-    { MultiTexCoord4fvARB_names, 403 },
-    { MultiTexCoord3fARB_names, 394 },
-    { MultTransposeMatrixfARB_names, 410 },
-    { CompressedTexImage2DARB_names, 555 },
-    { MultiTexCoord4dARB_names, 400 },
-    { MultiTexCoord1sARB_names, 382 },
-    { MultiTexCoord1dvARB_names, 377 },
-    { MultiTexCoord1ivARB_names, 381 },
-    { MultiTexCoord2ivARB_names, 389 },
-    { MultiTexCoord1iARB_names, 380 },
-    { GetCompressedTexImageARB_names, 560 },
-    { MultiTexCoord4svARB_names, 407 },
-    { MultiTexCoord1fARB_names, 378 },
-    { MultiTexCoord4fARB_names, 402 },
-    { LoadTransposeMatrixfARB_names, 408 },
-    { MultiTexCoord2fvARB_names, 387 },
-    { NULL, 0 }
+    { SampleCoverageARB_names, SampleCoverageARB_remap_index, 412 },
+    { MultiTexCoord3sARB_names, -1, 398 },
+    { ActiveTextureARB_names, -1, 374 },
+    { CompressedTexSubImage2DARB_names, CompressedTexSubImage2DARB_remap_index, 558 },
+    { CompressedTexImage3DARB_names, CompressedTexImage3DARB_remap_index, 554 },
+    { MultiTexCoord1fvARB_names, -1, 379 },
+    { MultTransposeMatrixdARB_names, MultTransposeMatrixdARB_remap_index, 411 },
+    { CompressedTexImage1DARB_names, CompressedTexImage1DARB_remap_index, 556 },
+    { MultiTexCoord3dARB_names, -1, 392 },
+    { MultiTexCoord2iARB_names, -1, 388 },
+    { MultiTexCoord2svARB_names, -1, 391 },
+    { MultiTexCoord2fARB_names, -1, 386 },
+    { LoadTransposeMatrixdARB_names, LoadTransposeMatrixdARB_remap_index, 409 },
+    { MultiTexCoord3fvARB_names, -1, 395 },
+    { MultiTexCoord4sARB_names, -1, 406 },
+    { MultiTexCoord2dvARB_names, -1, 385 },
+    { MultiTexCoord1svARB_names, -1, 383 },
+    { MultiTexCoord3svARB_names, -1, 399 },
+    { MultiTexCoord4iARB_names, -1, 404 },
+    { MultiTexCoord3iARB_names, -1, 396 },
+    { MultiTexCoord1dARB_names, -1, 376 },
+    { MultiTexCoord3dvARB_names, -1, 393 },
+    { MultiTexCoord3ivARB_names, -1, 397 },
+    { MultiTexCoord2sARB_names, -1, 390 },
+    { MultiTexCoord4ivARB_names, -1, 405 },
+    { CompressedTexSubImage1DARB_names, CompressedTexSubImage1DARB_remap_index, 559 },
+    { ClientActiveTextureARB_names, -1, 375 },
+    { CompressedTexSubImage3DARB_names, CompressedTexSubImage3DARB_remap_index, 557 },
+    { MultiTexCoord2dARB_names, -1, 384 },
+    { MultiTexCoord4dvARB_names, -1, 401 },
+    { MultiTexCoord4fvARB_names, -1, 403 },
+    { MultiTexCoord3fARB_names, -1, 394 },
+    { MultTransposeMatrixfARB_names, MultTransposeMatrixfARB_remap_index, 410 },
+    { CompressedTexImage2DARB_names, CompressedTexImage2DARB_remap_index, 555 },
+    { MultiTexCoord4dARB_names, -1, 400 },
+    { MultiTexCoord1sARB_names, -1, 382 },
+    { MultiTexCoord1dvARB_names, -1, 377 },
+    { MultiTexCoord1ivARB_names, -1, 381 },
+    { MultiTexCoord2ivARB_names, -1, 389 },
+    { MultiTexCoord1iARB_names, -1, 380 },
+    { GetCompressedTexImageARB_names, GetCompressedTexImageARB_remap_index, 560 },
+    { MultiTexCoord4svARB_names, -1, 407 },
+    { MultiTexCoord1fARB_names, -1, 378 },
+    { MultiTexCoord4fARB_names, -1, 402 },
+    { LoadTransposeMatrixfARB_names, LoadTransposeMatrixfARB_remap_index, 408 },
+    { MultiTexCoord2fvARB_names, -1, 387 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_VERSION_1_4)
 static const struct dri_extension_function GL_VERSION_1_4_functions[] = {
-    { PointParameteriNV_names, 642 },
-    { SecondaryColor3iEXT_names, 567 },
-    { WindowPos3fMESA_names, 523 },
-    { WindowPos2dvMESA_names, 514 },
-    { SecondaryColor3bEXT_names, 561 },
-    { PointParameterfEXT_names, 458 },
-    { FogCoorddEXT_names, 547 },
-    { FogCoordfEXT_names, 545 },
-    { WindowPos2svMESA_names, 520 },
-    { WindowPos3dMESA_names, 521 },
-    { PointParameterfvEXT_names, 459 },
-    { WindowPos2fvMESA_names, 516 },
-    { SecondaryColor3bvEXT_names, 562 },
-    { SecondaryColor3sEXT_names, 569 },
-    { SecondaryColor3dEXT_names, 563 },
-    { WindowPos2dMESA_names, 513 },
-    { SecondaryColorPointerEXT_names, 577 },
-    { SecondaryColor3uiEXT_names, 573 },
-    { SecondaryColor3usvEXT_names, 576 },
-    { WindowPos3dvMESA_names, 522 },
-    { PointParameterivNV_names, 643 },
-    { WindowPos3fvMESA_names, 524 },
-    { SecondaryColor3ivEXT_names, 568 },
-    { WindowPos2iMESA_names, 517 },
-    { SecondaryColor3fvEXT_names, 566 },
-    { WindowPos3sMESA_names, 527 },
-    { WindowPos2ivMESA_names, 518 },
-    { MultiDrawElementsEXT_names, 645 },
-    { WindowPos2sMESA_names, 519 },
-    { FogCoordPointerEXT_names, 549 },
-    { SecondaryColor3ubvEXT_names, 572 },
-    { SecondaryColor3uivEXT_names, 574 },
-    { WindowPos3iMESA_names, 525 },
-    { SecondaryColor3dvEXT_names, 564 },
-    { MultiDrawArraysEXT_names, 644 },
-    { SecondaryColor3usEXT_names, 575 },
-    { FogCoordfvEXT_names, 546 },
-    { SecondaryColor3ubEXT_names, 571 },
-    { BlendFuncSeparateEXT_names, 537 },
-    { SecondaryColor3fEXT_names, 565 },
-    { WindowPos3ivMESA_names, 526 },
-    { SecondaryColor3svEXT_names, 570 },
-    { FogCoorddvEXT_names, 548 },
-    { WindowPos3svMESA_names, 528 },
-    { WindowPos2fMESA_names, 515 },
-    { NULL, 0 }
+    { PointParameteriNV_names, PointParameteriNV_remap_index, 642 },
+    { SecondaryColor3iEXT_names, SecondaryColor3iEXT_remap_index, 567 },
+    { WindowPos3fMESA_names, WindowPos3fMESA_remap_index, 523 },
+    { WindowPos2dvMESA_names, WindowPos2dvMESA_remap_index, 514 },
+    { SecondaryColor3bEXT_names, SecondaryColor3bEXT_remap_index, 561 },
+    { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 },
+    { FogCoorddEXT_names, FogCoorddEXT_remap_index, 547 },
+    { FogCoordfEXT_names, FogCoordfEXT_remap_index, 545 },
+    { WindowPos2svMESA_names, WindowPos2svMESA_remap_index, 520 },
+    { WindowPos3dMESA_names, WindowPos3dMESA_remap_index, 521 },
+    { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 },
+    { WindowPos2fvMESA_names, WindowPos2fvMESA_remap_index, 516 },
+    { SecondaryColor3bvEXT_names, SecondaryColor3bvEXT_remap_index, 562 },
+    { SecondaryColor3sEXT_names, SecondaryColor3sEXT_remap_index, 569 },
+    { SecondaryColor3dEXT_names, SecondaryColor3dEXT_remap_index, 563 },
+    { WindowPos2dMESA_names, WindowPos2dMESA_remap_index, 513 },
+    { SecondaryColorPointerEXT_names, SecondaryColorPointerEXT_remap_index, 577 },
+    { SecondaryColor3uiEXT_names, SecondaryColor3uiEXT_remap_index, 573 },
+    { SecondaryColor3usvEXT_names, SecondaryColor3usvEXT_remap_index, 576 },
+    { WindowPos3dvMESA_names, WindowPos3dvMESA_remap_index, 522 },
+    { PointParameterivNV_names, PointParameterivNV_remap_index, 643 },
+    { WindowPos3fvMESA_names, WindowPos3fvMESA_remap_index, 524 },
+    { SecondaryColor3ivEXT_names, SecondaryColor3ivEXT_remap_index, 568 },
+    { WindowPos2iMESA_names, WindowPos2iMESA_remap_index, 517 },
+    { SecondaryColor3fvEXT_names, SecondaryColor3fvEXT_remap_index, 566 },
+    { WindowPos3sMESA_names, WindowPos3sMESA_remap_index, 527 },
+    { WindowPos2ivMESA_names, WindowPos2ivMESA_remap_index, 518 },
+    { MultiDrawElementsEXT_names, MultiDrawElementsEXT_remap_index, 645 },
+    { WindowPos2sMESA_names, WindowPos2sMESA_remap_index, 519 },
+    { FogCoordPointerEXT_names, FogCoordPointerEXT_remap_index, 549 },
+    { SecondaryColor3ubvEXT_names, SecondaryColor3ubvEXT_remap_index, 572 },
+    { SecondaryColor3uivEXT_names, SecondaryColor3uivEXT_remap_index, 574 },
+    { WindowPos3iMESA_names, WindowPos3iMESA_remap_index, 525 },
+    { SecondaryColor3dvEXT_names, SecondaryColor3dvEXT_remap_index, 564 },
+    { MultiDrawArraysEXT_names, MultiDrawArraysEXT_remap_index, 644 },
+    { SecondaryColor3usEXT_names, SecondaryColor3usEXT_remap_index, 575 },
+    { FogCoordfvEXT_names, FogCoordfvEXT_remap_index, 546 },
+    { SecondaryColor3ubEXT_names, SecondaryColor3ubEXT_remap_index, 571 },
+    { BlendFuncSeparateEXT_names, BlendFuncSeparateEXT_remap_index, 537 },
+    { SecondaryColor3fEXT_names, SecondaryColor3fEXT_remap_index, 565 },
+    { WindowPos3ivMESA_names, WindowPos3ivMESA_remap_index, 526 },
+    { SecondaryColor3svEXT_names, SecondaryColor3svEXT_remap_index, 570 },
+    { FogCoorddvEXT_names, FogCoorddvEXT_remap_index, 548 },
+    { WindowPos3svMESA_names, WindowPos3svMESA_remap_index, 528 },
+    { WindowPos2fMESA_names, WindowPos2fMESA_remap_index, 515 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_VERSION_1_5)
 static const struct dri_extension_function GL_VERSION_1_5_functions[] = {
-    { BeginQueryARB_names, 703 },
-    { GetBufferSubDataARB_names, 695 },
-    { BufferSubDataARB_names, 690 },
-    { GetQueryivARB_names, 705 },
-    { GetQueryObjectivARB_names, 706 },
-    { BufferDataARB_names, 689 },
-    { EndQueryARB_names, 704 },
-    { GetBufferPointervARB_names, 694 },
-    { GetQueryObjectuivARB_names, 707 },
-    { GetBufferParameterivARB_names, 693 },
-    { DeleteQueriesARB_names, 701 },
-    { IsQueryARB_names, 702 },
-    { MapBufferARB_names, 697 },
-    { GenQueriesARB_names, 700 },
-    { IsBufferARB_names, 696 },
-    { DeleteBuffersARB_names, 691 },
-    { UnmapBufferARB_names, 698 },
-    { BindBufferARB_names, 688 },
-    { GenBuffersARB_names, 692 },
-    { NULL, 0 }
+    { BeginQueryARB_names, BeginQueryARB_remap_index, 703 },
+    { GetBufferSubDataARB_names, GetBufferSubDataARB_remap_index, 695 },
+    { BufferSubDataARB_names, BufferSubDataARB_remap_index, 690 },
+    { GetQueryivARB_names, GetQueryivARB_remap_index, 705 },
+    { GetQueryObjectivARB_names, GetQueryObjectivARB_remap_index, 706 },
+    { BufferDataARB_names, BufferDataARB_remap_index, 689 },
+    { EndQueryARB_names, EndQueryARB_remap_index, 704 },
+    { GetBufferPointervARB_names, GetBufferPointervARB_remap_index, 694 },
+    { GetQueryObjectuivARB_names, GetQueryObjectuivARB_remap_index, 707 },
+    { GetBufferParameterivARB_names, GetBufferParameterivARB_remap_index, 693 },
+    { DeleteQueriesARB_names, DeleteQueriesARB_remap_index, 701 },
+    { IsQueryARB_names, IsQueryARB_remap_index, 702 },
+    { MapBufferARB_names, MapBufferARB_remap_index, 697 },
+    { GenQueriesARB_names, GenQueriesARB_remap_index, 700 },
+    { IsBufferARB_names, IsBufferARB_remap_index, 696 },
+    { DeleteBuffersARB_names, DeleteBuffersARB_remap_index, 691 },
+    { UnmapBufferARB_names, UnmapBufferARB_remap_index, 698 },
+    { BindBufferARB_names, BindBufferARB_remap_index, 688 },
+    { GenBuffersARB_names, GenBuffersARB_remap_index, 692 },
+    { NULL, 0, 0 }
 };
 #endif
 
 #if defined(need_GL_VERSION_2_0)
 static const struct dri_extension_function GL_VERSION_2_0_functions[] = {
-    { StencilMaskSeparate_names, 815 },
-    { StencilOpSeparate_names, 814 },
-    { StencilFuncSeparate_names, 813 },
-    { NULL, 0 }
+    { StencilMaskSeparate_names, StencilMaskSeparate_remap_index, 815 },
+    { StencilOpSeparate_names, StencilOpSeparate_remap_index, 814 },
+    { StencilFuncSeparate_names, StencilFuncSeparate_remap_index, 813 },
+    { NULL, 0, 0 }
 };
 #endif
 

diff --git a/src/mesa/drivers/dri/common/utils.c b/src/mesa/drivers/dri/common/utils.c
index 41367b85d8520456a196cb3e100c91577bf64b8a..b6fb06ffac9e4a52920a8dc262a1088941fd41cc 100644 (file)
--- a/src/mesa/drivers/dri/common/utils.c
+++ b/src/mesa/drivers/dri/common/utils.c
@@ -34,6 +34,9 @@
 #include "mtypes.h"
 #include "extensions.h"
 #include "utils.h"
+#include "dispatch.h"
+
+unsigned driDispatchRemapTable[ driDispatchRemapTable_size ];
 
 #if defined(USE_X86_ASM)
 #include "x86/common_x86_asm.h"
@@ -176,6 +179,30 @@ driGetRendererString( char * buffer, const char * hardware_name,
 
 
 
+#define need_GL_ARB_multisample
+#define need_GL_ARB_transpose_matrix
+#define need_GL_ARB_window_pos
+#define need_GL_EXT_compiled_vertex_array
+#define need_GL_EXT_polygon_offset
+#define need_GL_EXT_texture_object
+#define need_GL_EXT_vertex_array
+#define need_GL_MESA_window_pos
+
+#include "extension_helper.h"
+
+static const struct dri_extension all_mesa_extensions[] = {
+   { "GL_ARB_multisample",           GL_ARB_multisample_functions },
+   { "GL_ARB_transpose_matrix",      GL_ARB_transpose_matrix_functions },
+   { "GL_ARB_window_pos",            GL_ARB_window_pos_functions },
+   { "GL_EXT_compiled_vertex_array", GL_EXT_compiled_vertex_array_functions },
+   { "GL_EXT_polygon_offset",        GL_EXT_polygon_offset_functions },
+   { "GL_EXT_texture_object",        GL_EXT_texture_object_functions },
+   { "GL_EXT_vertex_array",          GL_EXT_vertex_array_functions },
+   { "GL_MESA_window_pos",           GL_MESA_window_pos_functions },
+   { NULL,                           NULL }
+};
+
+
 /**
  * Enable extensions supported by the driver.
  * 
@@ -189,9 +216,15 @@ void driInitExtensions( GLcontext * ctx,
                        const struct dri_extension * extensions_to_enable,
                        GLboolean enable_imaging )
 {
+   static int first_time = 1;
    unsigned   i;
 
-   if ( enable_imaging ) {
+   if ( first_time ) {
+      first_time = 0;
+      driInitExtensions( ctx, all_mesa_extensions, GL_FALSE );
+   }
+
+   if ( (ctx != NULL) && enable_imaging ) {
       _mesa_enable_imaging_extensions( ctx );
    }
 
@@ -220,12 +253,14 @@ void driInitSingleExtension( GLcontext * ctx,
 {
     unsigned i;
 
+
     if ( ext->functions != NULL ) {
        for ( i = 0 ; ext->functions[i].strings != NULL ; i++ ) {
            const char * functions[16];
            const char * parameter_signature;
            const char * str = ext->functions[i].strings;
            unsigned j;
+           unsigned offset;
 
 
            /* Separate the parameter signature from the rest of the string.
@@ -260,14 +295,23 @@ void driInitSingleExtension( GLcontext * ctx,
 
            /* Add each entry-point to the dispatch table.
             */
-           for ( j = 0 ; functions[j] != NULL ; j++ ) {
-               _glapi_add_entrypoint( functions[j], 
-                                      ext->functions[i].offset );
+           offset = _glapi_add_dispatch( functions, parameter_signature );
+           if ( ext->functions[i].remap_index != -1 ) {
+               driDispatchRemapTable[ ext->functions[i].remap_index ] = offset;
+           }
+
+           if ( (ext->functions[i].offset != -1)
+                && (ext->functions[i].offset != offset) ) {
+               fprintf(stderr, "DISPATCH ERROR! %s -> %u != %u\n", functions[0],
+                       driDispatchRemapTable[ ext->functions[i].remap_index ],
+                       ext->functions[i].offset);
            }
        }
     }
 
-    _mesa_enable_extension( ctx, ext->name );
+    if ( ctx != NULL ) {
+       _mesa_enable_extension( ctx, ext->name );
+    }
 }
 
 

diff --git a/src/mesa/drivers/dri/common/utils.h b/src/mesa/drivers/dri/common/utils.h
index 6640229e475f637d1a3ef143a9d495e65d469b84..26d178f7478e019f3d57aced556fa3ef13dbcdce 100644 (file)
--- a/src/mesa/drivers/dri/common/utils.h
+++ b/src/mesa/drivers/dri/common/utils.h
@@ -54,10 +54,16 @@ struct dri_extension_function {
     const char * strings;
 
 
+    /**
+     * Location in the remap table where the dispatch offset should be
+     * stored.
+     */
+    int remap_index;
+
     /**
      * Offset of the function in the dispatch table.
      */
-    unsigned     offset;
+    int offset;
 };
 
 /**

diff --git a/src/mesa/drivers/dri/ffb/ffb_xmesa.c b/src/mesa/drivers/dri/ffb/ffb_xmesa.c
index f49b40aa83323aba5219f5879b9baa4312341210..e260e1de24be1c45772365fb9df95cd6fe1a5764 100644 (file)
--- a/src/mesa/drivers/dri/ffb/ffb_xmesa.c
+++ b/src/mesa/drivers/dri/ffb/ffb_xmesa.c
@@ -708,7 +708,7 @@ ffbFillInModes( unsigned pixel_bits, unsigned depth_bits,
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,

diff --git a/src/mesa/drivers/dri/i810/i810screen.c b/src/mesa/drivers/dri/i810/i810screen.c
index 1b9d4aa3699261bd3138af8f562332a8ae855b10..7c5f38e3586879921b521123f23c4ff831fb5b16 100644 (file)
--- a/src/mesa/drivers/dri/i810/i810screen.c
+++ b/src/mesa/drivers/dri/i810/i810screen.c
@@ -424,7 +424,7 @@ static const struct __DriverAPIRec i810API = {
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,

diff --git a/src/mesa/drivers/dri/i830/i830_context.c b/src/mesa/drivers/dri/i830/i830_context.c
index d408e47c4af6346c82e9dba0acfe99d11cd402bd..45fcbd2e3b6eb58c1270aaed31804d6ea4fb5a79 100644 (file)
--- a/src/mesa/drivers/dri/i830/i830_context.c
+++ b/src/mesa/drivers/dri/i830/i830_context.c
@@ -149,7 +149,7 @@ static void i830BufferSize(GLframebuffer *buffer,
 
 /* Extension strings exported by the i830 driver.
  */
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },

diff --git a/src/mesa/drivers/dri/i830/i830_screen.c b/src/mesa/drivers/dri/i830/i830_screen.c
index c77657d6f060e848fed26be86833f7119992b64b..b1a5618f41024d4ffaac833041856861ed90eef0 100644 (file)
--- a/src/mesa/drivers/dri/i830/i830_screen.c
+++ b/src/mesa/drivers/dri/i830/i830_screen.c
@@ -67,6 +67,7 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 const GLuint __driNConfigOptions = 2;
 
+extern const struct dri_extension card_extensions[];
 
 static int i830_malloc_proxy_buf(drmBufMapPtr buffers)
 {
@@ -502,7 +503,7 @@ i830FillInModes( unsigned pixel_bits, unsigned depth_bits,
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -538,6 +539,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                       (dri_priv->cpp == 2) ? 16 : 24,
                                       (dri_priv->cpp == 2) ? 0  : 8,
                                       (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/i915/i830_context.c b/src/mesa/drivers/dri/i915/i830_context.c
index c817397db57acd3ce40a06bfc6ea44365441d626..6088db67e2084ce12dfe2d07dc3675c4473e5865 100644 (file)
--- a/src/mesa/drivers/dri/i915/i830_context.c
+++ b/src/mesa/drivers/dri/i915/i830_context.c
@@ -38,7 +38,7 @@
  * Mesa's Driver Functions
  ***************************************/
 
-static const struct dri_extension card_extensions[] =
+static const struct dri_extension i830_extensions[] =
 {
     { "GL_ARB_texture_env_crossbar",       NULL },
     { NULL,                                NULL }
@@ -109,7 +109,7 @@ GLboolean i830CreateContext( const __GLcontextModes *mesaVis,
 
    intel->verts = TNL_CONTEXT(ctx)->clipspace.vertex_buf;
 
-   driInitExtensions( ctx, card_extensions, GL_FALSE );
+   driInitExtensions( ctx, i830_extensions, GL_FALSE );
 
    i830InitState( i830 );
 

diff --git a/src/mesa/drivers/dri/i915/i915_context.c b/src/mesa/drivers/dri/i915/i915_context.c
index 66628365a660546681d0898b7643e274700e2664..42f91241b263a6677733740cd85fa168d818f2e5 100644 (file)
--- a/src/mesa/drivers/dri/i915/i915_context.c
+++ b/src/mesa/drivers/dri/i915/i915_context.c
@@ -45,7 +45,7 @@
  * Mesa's Driver Functions
  ***************************************/
 
-static const struct dri_extension card_extensions[] =
+static const struct dri_extension i915_extensions[] =
 {
     { "GL_ARB_depth_texture",              NULL },
     { "GL_ARB_fragment_program",           NULL },
@@ -166,7 +166,7 @@ GLboolean i915CreateContext( const __GLcontextModes *mesaVis,
    ctx->Const.MaxFragmentProgramAddressRegs = 0; /* I don't think we have one */
 
 
-   driInitExtensions( ctx, card_extensions, GL_FALSE );
+   driInitExtensions( ctx, i915_extensions, GL_FALSE );
 
 
    _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12, 

diff --git a/src/mesa/drivers/dri/i915/intel_context.c b/src/mesa/drivers/dri/i915/intel_context.c
index d30136a7d5d39e0119d319a1996b7cdbaff1a52f..4639105e1f8b36436366650126d9fb76e3a6e72a 100644 (file)
--- a/src/mesa/drivers/dri/i915/intel_context.c
+++ b/src/mesa/drivers/dri/i915/intel_context.c
@@ -153,7 +153,7 @@ static void intelBufferSize(GLframebuffer *buffer,
  * It appears that ARB_texture_env_crossbar has "disappeared" compared to the
  * old i830-specific driver.
  */
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },

diff --git a/src/mesa/drivers/dri/i915/intel_screen.c b/src/mesa/drivers/dri/i915/intel_screen.c
index ca8f34657ca92fb914d593547d73ee52bc20ee1d..e474850c6345d6ad50a8a1e1645733d7fae74a8c 100644 (file)
--- a/src/mesa/drivers/dri/i915/intel_screen.c
+++ b/src/mesa/drivers/dri/i915/intel_screen.c
@@ -54,6 +54,7 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 const GLuint __driNConfigOptions = 1;
 
+extern const struct dri_extension card_extensions[];
 
 static void intelPrintDRIInfo(intelScreenPrivate *intelScreen,
                             __DRIscreenPrivate *sPriv,
@@ -457,7 +458,7 @@ intelFillInModes( unsigned pixel_bits, unsigned depth_bits,
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -493,6 +494,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                        (dri_priv->cpp == 2) ? 16 : 24,
                                        (dri_priv->cpp == 2) ? 0  : 8,
                                        (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/mach64/mach64_screen.c b/src/mesa/drivers/dri/mach64/mach64_screen.c
index 91aa31eecc0bbe0f23d2fce36fc8fa4251da630a..df1ed92fe7da88f5bf0adffda951549484e7363f 100644 (file)
--- a/src/mesa/drivers/dri/mach64/mach64_screen.c
+++ b/src/mesa/drivers/dri/mach64/mach64_screen.c
@@ -498,7 +498,7 @@ static struct __DriverAPIRec mach64API = {
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,

diff --git a/src/mesa/drivers/dri/mga/mga_xmesa.c b/src/mesa/drivers/dri/mga/mga_xmesa.c
index e310f619586c87743ebbe2170563bc62ad02705f..ef080b5695af60b70130e257c11e06f530e76d6f 100644 (file)
--- a/src/mesa/drivers/dri/mga/mga_xmesa.c
+++ b/src/mesa/drivers/dri/mga/mga_xmesa.c
@@ -934,7 +934,7 @@ static const struct __DriverAPIRec mgaAPI = {
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -970,6 +970,20 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                      (dri_priv->cpp == 2) ? 16 : 24,
                                      (dri_priv->cpp == 2) ? 0  : 8,
                                      (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
+      driInitExtensions( NULL, g400_extensions, GL_FALSE );
+      driInitSingleExtension( NULL, ARB_vp_extension );
+      driInitExtensions( NULL, NV_vp_extensions, GL_FALSE );
+
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/r128/r128_context.c b/src/mesa/drivers/dri/r128/r128_context.c
index c0036c14908ce74ee6a9ed7b692912f02e59896d..f071bbecbfd9153c3176e541736fd07389713a1d 100644 (file)
--- a/src/mesa/drivers/dri/r128/r128_context.c
+++ b/src/mesa/drivers/dri/r128/r128_context.c
@@ -71,7 +71,7 @@ int R128_DEBUG = 0;
 #define need_GL_EXT_blend_minmax
 #include "extension_helper.h"
 
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },

diff --git a/src/mesa/drivers/dri/r128/r128_screen.c b/src/mesa/drivers/dri/r128/r128_screen.c
index f5d0287ed9f025fe58ce207e1734ac0b5918143d..b6177bf691d5ce7fc6258bb0ab4733e750d7655d 100644 (file)
--- a/src/mesa/drivers/dri/r128/r128_screen.c
+++ b/src/mesa/drivers/dri/r128/r128_screen.c
@@ -75,6 +75,8 @@ static const GLuint __driNConfigOptions = 4;
 static const GLuint __driNConfigOptions = 3;
 #endif
 
+extern const struct dri_extension card_extensions[];
+
 #if 1
 /* Including xf86PciInfo.h introduces a bunch of errors...
  */
@@ -482,7 +484,7 @@ r128FillInModes( unsigned pixel_bits, unsigned depth_bits,
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -519,6 +521,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                       (dri_priv->bpp == 16) ? 16 : 24,
                                       (dri_priv->bpp == 16) ? 0  : 8,
                                       (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/r200/r200_context.c b/src/mesa/drivers/dri/r200/r200_context.c
index 06834fb626e4d59758a49f95d616274d70d05f6c..fc5cf5a33f3062b6abbbea91533a89a74c42ef30 100644 (file)
--- a/src/mesa/drivers/dri/r200/r200_context.c
+++ b/src/mesa/drivers/dri/r200/r200_context.c
@@ -131,7 +131,7 @@ static const GLubyte *r200GetString( GLcontext *ctx, GLenum name )
 
 /* Extension strings exported by the R200 driver.
  */
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },
@@ -162,17 +162,17 @@ static const struct dri_extension card_extensions[] =
     { NULL,                                NULL }
 };
 
-static const struct dri_extension blend_extensions[] = {
+const struct dri_extension blend_extensions[] = {
     { "GL_EXT_blend_equation_separate",    GL_EXT_blend_equation_separate_functions },
     { "GL_EXT_blend_func_separate",        GL_EXT_blend_func_separate_functions },
     { NULL,                                NULL }
 };
                                                         
-static const struct dri_extension ARB_vp_extension[] = {
+const struct dri_extension ARB_vp_extension[] = {
     { "GL_ARB_vertex_program",             GL_ARB_vertex_program_functions }
 };
 
-static const struct dri_extension NV_vp_extension[] = {
+const struct dri_extension NV_vp_extension[] = {
     { "GL_NV_vertex_program",              GL_NV_vertex_program_functions }
 };
 

diff --git a/src/mesa/drivers/dri/r200/r200_screen.c b/src/mesa/drivers/dri/r200/r200_screen.c
index ddb3a91b1dc728ad004faf9d6ae3db24e0cb0f31..f0e09d5fc4e4df37c9521722d4134027ea7471c0 100644 (file)
--- a/src/mesa/drivers/dri/r200/r200_screen.c
+++ b/src/mesa/drivers/dri/r200/r200_screen.c
@@ -90,6 +90,11 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 static const GLuint __driNConfigOptions = 17;
 
+extern const struct dri_extension card_extensions[];
+extern const struct dri_extension blend_extensions[];
+extern const struct dri_extension ARB_vp_extension[];
+extern const struct dri_extension NV_vp_extension[];
+
 #if 1
 /* Including xf86PciInfo.h introduces a bunch of errors...
  */
@@ -642,7 +647,7 @@ static const struct __DriverAPIRec r200API = {
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -678,6 +683,19 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                       (dri_priv->bpp == 16) ? 16 : 24,
                                       (dri_priv->bpp == 16) ? 0  : 8,
                                       (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
+      driInitExtensions( NULL, blend_extensions, GL_FALSE );
+      driInitSingleExtension( NULL, ARB_vp_extension );
+      driInitSingleExtension( NULL, NV_vp_extension );
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/r300/r300_context.c b/src/mesa/drivers/dri/r300/r300_context.c
index 9100ac2565b7345743023fd9b1f44dc13ec80ed4..b3017372fe6f47426292d92d8807afb666b45f73 100644 (file)
--- a/src/mesa/drivers/dri/r300/r300_context.c
+++ b/src/mesa/drivers/dri/r300/r300_context.c
@@ -73,7 +73,7 @@ int hw_tcl_on=0;
 #define need_GL_EXT_blend_minmax
 #include "extension_helper.h"
 
-static const struct dri_extension card_extensions[] = {
+const struct dri_extension card_extensions[] = {
   {"GL_ARB_multisample",               GL_ARB_multisample_functions},
   {"GL_ARB_multitexture",              NULL},
   {"GL_ARB_texture_border_clamp",      NULL},

diff --git a/src/mesa/drivers/dri/r300/radeon_screen.c b/src/mesa/drivers/dri/r300/radeon_screen.c
index bc65dd81b8a0a52442f292af5acddad819644b4a..18919ddeb126eccda50f93264ec6a2ff0d2c07c0 100644 (file)
--- a/src/mesa/drivers/dri/r300/radeon_screen.c
+++ b/src/mesa/drivers/dri/r300/radeon_screen.c
@@ -132,6 +132,7 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 static const GLuint __driR300NConfigOptions = 13;
 
+extern const struct dri_extension card_extensions[];
 
 #ifndef RADEON_DEBUG
 int RADEON_DEBUG = 0;
@@ -789,7 +790,7 @@ static const struct __DriverAPIRec radeonAPI = {
  * \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
  *         failure.
  */
-void *__driCreateNewScreen_20050725(__DRInativeDisplay * dpy, int scrn,
+void *__driCreateNewScreen_20050727(__DRInativeDisplay * dpy, int scrn,
                           __DRIscreen * psc, const __GLcontextModes * modes,
                           const __DRIversion * ddx_version,
                           const __DRIversion * dri_version,
@@ -826,6 +827,15 @@ void *__driCreateNewScreen_20050725(__DRInativeDisplay * dpy, int scrn,
                                                   16) ? 0 : 8,
                                                  (dri_priv->backOffset !=
                                                   dri_priv->depthOffset));
+               /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+                * enable the extensions.  It just makes sure that all the dispatch offsets for all
+                * the extensions that *might* be enables are known.  This is needed because the
+                * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+                * enable the extensions until we have a context pointer.
+                *
+                * Hello chicken.  Hello egg.  How are you two today?
+                */
+               driInitExtensions( NULL, card_extensions, GL_FALSE );
        }
 
        return (void *)psp;

diff --git a/src/mesa/drivers/dri/radeon/radeon_context.c b/src/mesa/drivers/dri/radeon/radeon_context.c
index 12f5f4011515fbcbb01a4ea13e9cc9c87ee08eab..c96f38e0abba4676c099ec13f77f5ee6ffef6fbd 100644 (file)
--- a/src/mesa/drivers/dri/radeon/radeon_context.c
+++ b/src/mesa/drivers/dri/radeon/radeon_context.c
@@ -125,7 +125,7 @@ static const GLubyte *radeonGetString( GLcontext *ctx, GLenum name )
 
 /* Extension strings exported by the R100 driver.
  */
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },

diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.c b/src/mesa/drivers/dri/radeon/radeon_screen.c
index 9cd60875b1bcddd17989a25b11ee91f6af367930..0a2bb7e91611998d2304adf8b00921cbc2162f56 100644 (file)
--- a/src/mesa/drivers/dri/radeon/radeon_screen.c
+++ b/src/mesa/drivers/dri/radeon/radeon_screen.c
@@ -83,6 +83,8 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 static const GLuint __driNConfigOptions = 13;
 
+extern const struct dri_extension card_extensions[];
+
 #if 1
 /* Including xf86PciInfo.h introduces a bunch of errors...
  */
@@ -566,7 +568,7 @@ static struct __DriverAPIRec radeonAPI = {
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -602,6 +604,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                         (dri_priv->bpp == 16) ? 16 : 24,
                                         (dri_priv->bpp == 16) ? 0  : 8,
                                         (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/savage/savage_xmesa.c b/src/mesa/drivers/dri/savage/savage_xmesa.c
index bb8f015e7606f3f1fc53df8c341f224163e93080..fa20d10edb3f95e3c76d4623d886fd32860766df 100644 (file)
--- a/src/mesa/drivers/dri/savage/savage_xmesa.c
+++ b/src/mesa/drivers/dri/savage/savage_xmesa.c
@@ -128,7 +128,7 @@ unsigned long time_sum=0;
 struct timeval tv_s1,tv_f1;
 #endif
 
-static const struct dri_extension common_extensions[] =
+static const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },
@@ -534,7 +534,7 @@ savageCreateContext( const __GLcontextModes *mesaVis,
                                       debug_control );
 #endif
 
-   driInitExtensions( ctx, common_extensions, GL_TRUE );
+   driInitExtensions( ctx, card_extensions, GL_TRUE );
    if (savageScreen->chipset >= S3_SAVAGE4)
        driInitExtensions( ctx, s4_extensions, GL_FALSE );
    if (ctx->Mesa_DXTn ||
@@ -997,7 +997,7 @@ savageFillInModes( unsigned pixel_bits, unsigned depth_bits,
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -1033,6 +1033,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
                                         (dri_priv->cpp == 2) ? 16 : 24,
                                         (dri_priv->cpp == 2) ? 0  : 8,
                                         (dri_priv->backOffset != dri_priv->depthOffset) );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
    }
 
    return (void *) psp;

diff --git a/src/mesa/drivers/dri/sis/sis_context.c b/src/mesa/drivers/dri/sis/sis_context.c
index 2c544524587e4e2b0a4633e06f5b3f7e472c68b2..6f48eed721ef0ed16f3f9b8cf2ebdb26f098df33 100644 (file)
--- a/src/mesa/drivers/dri/sis/sis_context.c
+++ b/src/mesa/drivers/dri/sis/sis_context.c
@@ -64,7 +64,7 @@ int GlobalCurrentHwcx = -1;
 int GlobalHwcxCountBase = 1;
 int GlobalCmdQueueLen = 0;
 
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },

diff --git a/src/mesa/drivers/dri/sis/sis_screen.c b/src/mesa/drivers/dri/sis/sis_screen.c
index 592852e94184ccda44e516f7ff924d7e19306129..174a74169ceeef8bfa3a9314c00ac6579bea44f1 100644 (file)
--- a/src/mesa/drivers/dri/sis/sis_screen.c
+++ b/src/mesa/drivers/dri/sis/sis_screen.c
@@ -413,7 +413,7 @@ static struct __DriverAPIRec sisAPI = {
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn,
                             __DRIscreen *psc,
                             const __GLcontextModes *modes,
                             const __DRIversion *ddx_version,

diff --git a/src/mesa/drivers/dri/tdfx/tdfx_context.c b/src/mesa/drivers/dri/tdfx/tdfx_context.c
index 724416197f2109a26ae3fb7c1376af0958f339c6..d90d4f06b96d476a94a4d0b96df03bc0b5f2ce3a 100644 (file)
--- a/src/mesa/drivers/dri/tdfx/tdfx_context.c
+++ b/src/mesa/drivers/dri/tdfx/tdfx_context.c
@@ -83,7 +83,7 @@
 /**
  * Common extension strings exported by all cards
  */
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_texture_mirrored_repeat",    NULL },
@@ -123,7 +123,7 @@ static const struct dri_extension card_extensions[] =
 /**
  * Extension strings exported only by Naplam (e.g., Voodoo4 & Voodoo5) cards.
  */
-static const struct dri_extension napalm_extensions[] =
+const struct dri_extension napalm_extensions[] =
 {
     { "GL_ARB_texture_compression",        GL_ARB_texture_compression_functions },
     { "GL_ARB_texture_env_combine",        NULL },

diff --git a/src/mesa/drivers/dri/tdfx/tdfx_screen.c b/src/mesa/drivers/dri/tdfx/tdfx_screen.c
index b373129646bd2bbfca0dc6a8087800d70ecbc50d..0da4d7e3c2eb93780694045d5282ef6c34893515 100644 (file)
--- a/src/mesa/drivers/dri/tdfx/tdfx_screen.c
+++ b/src/mesa/drivers/dri/tdfx/tdfx_screen.c
@@ -65,6 +65,9 @@ DRI_CONF_END;
 
 static const GLuint __driNConfigOptions = 1;
 
+extern const struct dri_extension card_extensions[];
+extern const struct dri_extension napalm_extensions[];
+
 static GLboolean
 tdfxCreateScreen( __DRIscreenPrivate *sPriv )
 {
@@ -426,7 +429,7 @@ static __GLcontextModes *tdfxFillInModes(unsigned pixel_bits,
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
                             const __DRIversion * dri_version,
@@ -467,6 +470,17 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc
       *driver_modes = tdfxFillInModes(bpp, (bpp == 16) ? 16 : 24,
                                (bpp == 16) ? 0 : 8,
                                (dri_priv->backOffset!=dri_priv->depthOffset));
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
+      driInitExtensions( NULL, napalm_extensions, GL_FALSE );
    }
 
    return (void *)psp;

diff --git a/src/mesa/drivers/dri/trident/trident_context.c b/src/mesa/drivers/dri/trident/trident_context.c
index 0af70e96fc9738f7d426ac01d6512c1fc7c5172a..8d0717937e8ff35d6c4b94204ebe87f469c5d558 100644 (file)
--- a/src/mesa/drivers/dri/trident/trident_context.c
+++ b/src/mesa/drivers/dri/trident/trident_context.c
@@ -426,7 +426,7 @@ static struct __DriverAPIRec tridentAPI = {
 };
 
 
-PUBLIC void *__driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn,
+PUBLIC void *__driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn,
                                    __DRIscreen *psc,
                                    const __GLcontextModes * modes,
                                    const __DRIversion * ddx_version,

diff --git a/src/mesa/drivers/dri/unichrome/via_context.c b/src/mesa/drivers/dri/unichrome/via_context.c
index ca31245b0fd86bade88f2ca5c37d7b413653003f..abcdcd70a5e5e2250d0562b692fcfbd19280ba37 100644 (file)
--- a/src/mesa/drivers/dri/unichrome/via_context.c
+++ b/src/mesa/drivers/dri/unichrome/via_context.c
@@ -251,7 +251,7 @@ static void viaBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height)
 
 /* Extension strings exported by the Unichrome driver.
  */
-static const struct dri_extension card_extensions[] =
+const struct dri_extension card_extensions[] =
 {
     { "GL_ARB_multisample",                GL_ARB_multisample_functions },
     { "GL_ARB_multitexture",               NULL },

diff --git a/src/mesa/drivers/dri/unichrome/via_screen.c b/src/mesa/drivers/dri/unichrome/via_screen.c
index 8de73539259ac96eb2b36cc07953060bd1eefcf7..2ae2322f8ac5e30852c0192414e671c01ddbec9f 100644 (file)
--- a/src/mesa/drivers/dri/unichrome/via_screen.c
+++ b/src/mesa/drivers/dri/unichrome/via_screen.c
@@ -61,6 +61,7 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 static const GLuint __driNConfigOptions = 3;
 
+extern const struct dri_extension card_extensions[];
 
 static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
 
@@ -402,7 +403,7 @@ viaFillInModes( unsigned pixel_bits, GLboolean have_back_buffer )
  *         failure.
  */
 PUBLIC
-void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn,
+void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn,
                             __DRIscreen *psc,
                             const __GLcontextModes * modes,
                             const __DRIversion * ddx_version,
@@ -437,6 +438,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn,
       VIADRIPtr dri_priv = (VIADRIPtr) psp->pDevPriv;
       *driver_modes = viaFillInModes( dri_priv->bytesPerPixel * 8,
                                      GL_TRUE );
+
+      /* Calling driInitExtensions here, with a NULL context pointer, does not actually
+       * enable the extensions.  It just makes sure that all the dispatch offsets for all
+       * the extensions that *might* be enables are known.  This is needed because the
+       * dispatch offsets need to be known when _mesa_context_create is called, but we can't
+       * enable the extensions until we have a context pointer.
+       *
+       * Hello chicken.  Hello egg.  How are you two today?
+       */
+      driInitExtensions( NULL, card_extensions, GL_FALSE );
    }
 
    fprintf(stderr, "%s - succeeded\n", __FUNCTION__);

diff --git a/src/mesa/glapi/dispatch.h b/src/mesa/glapi/dispatch.h
index 3295598e2d1bd4d6fe170dc0beaa42f31d31db6a..1e61edcf9f4639d106c4501122ee233163ac8d8d 100644 (file)
--- a/src/mesa/glapi/dispatch.h
+++ b/src/mesa/glapi/dispatch.h
@@ -44,7 +44,7 @@
 #define GET_by_offset(disp, offset) \
     (((_glapi_proc *)(disp))[offset])
 #define SET_by_offset(disp, offset, fn) \
-    ((((_glapi_proc *)(disp))[offset]) = fn)
+    ((((_glapi_proc *)(disp))[offset]) = (_glapi_proc) fn)
 
 #define CALL_NewList(disp, parameters) (*((disp)->NewList)) parameters
 #define GET_NewList(disp) ((disp)->NewList)
@@ -1270,6 +1270,9 @@
 #define CALL_MultiTexCoord4svARB(disp, parameters) (*((disp)->MultiTexCoord4svARB)) parameters
 #define GET_MultiTexCoord4svARB(disp) ((disp)->MultiTexCoord4svARB)
 #define SET_MultiTexCoord4svARB(disp, fn) ((disp)->MultiTexCoord4svARB = fn)
+
+#if !defined(IN_DRI_DRIVER)
+
 #define CALL_LoadTransposeMatrixfARB(disp, parameters) (*((disp)->LoadTransposeMatrixfARB)) parameters
 #define GET_LoadTransposeMatrixfARB(disp) ((disp)->LoadTransposeMatrixfARB)
 #define SET_LoadTransposeMatrixfARB(disp, fn) ((disp)->LoadTransposeMatrixfARB = fn)
@@ -2495,4 +2498,1645 @@
 #define GET_StencilMaskSeparate(disp) ((disp)->StencilMaskSeparate)
 #define SET_StencilMaskSeparate(disp, fn) ((disp)->StencilMaskSeparate = fn)
 
+#else
+
+#define driDispatchRemapTable_size 408
+extern unsigned driDispatchRemapTable[ driDispatchRemapTable_size ];
+
+#define LoadTransposeMatrixfARB_remap_index 0
+#define LoadTransposeMatrixdARB_remap_index 1
+#define MultTransposeMatrixfARB_remap_index 2
+#define MultTransposeMatrixdARB_remap_index 3
+#define SampleCoverageARB_remap_index 4
+#define DrawBuffersARB_remap_index 5
+#define PolygonOffsetEXT_remap_index 6
+#define GetTexFilterFuncSGIS_remap_index 7
+#define TexFilterFuncSGIS_remap_index 8
+#define GetHistogramEXT_remap_index 9
+#define GetHistogramParameterfvEXT_remap_index 10
+#define GetHistogramParameterivEXT_remap_index 11
+#define GetMinmaxEXT_remap_index 12
+#define GetMinmaxParameterfvEXT_remap_index 13
+#define GetMinmaxParameterivEXT_remap_index 14
+#define GetConvolutionFilterEXT_remap_index 15
+#define GetConvolutionParameterfvEXT_remap_index 16
+#define GetConvolutionParameterivEXT_remap_index 17
+#define GetSeparableFilterEXT_remap_index 18
+#define GetColorTableSGI_remap_index 19
+#define GetColorTableParameterfvSGI_remap_index 20
+#define GetColorTableParameterivSGI_remap_index 21
+#define PixelTexGenSGIX_remap_index 22
+#define PixelTexGenParameteriSGIS_remap_index 23
+#define PixelTexGenParameterivSGIS_remap_index 24
+#define PixelTexGenParameterfSGIS_remap_index 25
+#define PixelTexGenParameterfvSGIS_remap_index 26
+#define GetPixelTexGenParameterivSGIS_remap_index 27
+#define GetPixelTexGenParameterfvSGIS_remap_index 28
+#define TexImage4DSGIS_remap_index 29
+#define TexSubImage4DSGIS_remap_index 30
+#define AreTexturesResidentEXT_remap_index 31
+#define GenTexturesEXT_remap_index 32
+#define IsTextureEXT_remap_index 33
+#define DetailTexFuncSGIS_remap_index 34
+#define GetDetailTexFuncSGIS_remap_index 35
+#define SharpenTexFuncSGIS_remap_index 36
+#define GetSharpenTexFuncSGIS_remap_index 37
+#define SampleMaskSGIS_remap_index 38
+#define SamplePatternSGIS_remap_index 39
+#define ColorPointerEXT_remap_index 40
+#define EdgeFlagPointerEXT_remap_index 41
+#define IndexPointerEXT_remap_index 42
+#define NormalPointerEXT_remap_index 43
+#define TexCoordPointerEXT_remap_index 44
+#define VertexPointerEXT_remap_index 45
+#define SpriteParameterfSGIX_remap_index 46
+#define SpriteParameterfvSGIX_remap_index 47
+#define SpriteParameteriSGIX_remap_index 48
+#define SpriteParameterivSGIX_remap_index 49
+#define PointParameterfEXT_remap_index 50
+#define PointParameterfvEXT_remap_index 51
+#define GetInstrumentsSGIX_remap_index 52
+#define InstrumentsBufferSGIX_remap_index 53
+#define PollInstrumentsSGIX_remap_index 54
+#define ReadInstrumentsSGIX_remap_index 55
+#define StartInstrumentsSGIX_remap_index 56
+#define StopInstrumentsSGIX_remap_index 57
+#define FrameZoomSGIX_remap_index 58
+#define TagSampleBufferSGIX_remap_index 59
+#define ReferencePlaneSGIX_remap_index 60
+#define FlushRasterSGIX_remap_index 61
+#define GetListParameterfvSGIX_remap_index 62
+#define GetListParameterivSGIX_remap_index 63
+#define ListParameterfSGIX_remap_index 64
+#define ListParameterfvSGIX_remap_index 65
+#define ListParameteriSGIX_remap_index 66
+#define ListParameterivSGIX_remap_index 67
+#define FragmentColorMaterialSGIX_remap_index 68
+#define FragmentLightfSGIX_remap_index 69
+#define FragmentLightfvSGIX_remap_index 70
+#define FragmentLightiSGIX_remap_index 71
+#define FragmentLightivSGIX_remap_index 72
+#define FragmentLightModelfSGIX_remap_index 73
+#define FragmentLightModelfvSGIX_remap_index 74
+#define FragmentLightModeliSGIX_remap_index 75
+#define FragmentLightModelivSGIX_remap_index 76
+#define FragmentMaterialfSGIX_remap_index 77
+#define FragmentMaterialfvSGIX_remap_index 78
+#define FragmentMaterialiSGIX_remap_index 79
+#define FragmentMaterialivSGIX_remap_index 80
+#define GetFragmentLightfvSGIX_remap_index 81
+#define GetFragmentLightivSGIX_remap_index 82
+#define GetFragmentMaterialfvSGIX_remap_index 83
+#define GetFragmentMaterialivSGIX_remap_index 84
+#define LightEnviSGIX_remap_index 85
+#define VertexWeightfEXT_remap_index 86
+#define VertexWeightfvEXT_remap_index 87
+#define VertexWeightPointerEXT_remap_index 88
+#define FlushVertexArrayRangeNV_remap_index 89
+#define VertexArrayRangeNV_remap_index 90
+#define CombinerParameterfvNV_remap_index 91
+#define CombinerParameterfNV_remap_index 92
+#define CombinerParameterivNV_remap_index 93
+#define CombinerParameteriNV_remap_index 94
+#define CombinerInputNV_remap_index 95
+#define CombinerOutputNV_remap_index 96
+#define FinalCombinerInputNV_remap_index 97
+#define GetCombinerInputParameterfvNV_remap_index 98
+#define GetCombinerInputParameterivNV_remap_index 99
+#define GetCombinerOutputParameterfvNV_remap_index 100
+#define GetCombinerOutputParameterivNV_remap_index 101
+#define GetFinalCombinerInputParameterfvNV_remap_index 102
+#define GetFinalCombinerInputParameterivNV_remap_index 103
+#define ResizeBuffersMESA_remap_index 104
+#define WindowPos2dMESA_remap_index 105
+#define WindowPos2dvMESA_remap_index 106
+#define WindowPos2fMESA_remap_index 107
+#define WindowPos2fvMESA_remap_index 108
+#define WindowPos2iMESA_remap_index 109
+#define WindowPos2ivMESA_remap_index 110
+#define WindowPos2sMESA_remap_index 111
+#define WindowPos2svMESA_remap_index 112
+#define WindowPos3dMESA_remap_index 113
+#define WindowPos3dvMESA_remap_index 114
+#define WindowPos3fMESA_remap_index 115
+#define WindowPos3fvMESA_remap_index 116
+#define WindowPos3iMESA_remap_index 117
+#define WindowPos3ivMESA_remap_index 118
+#define WindowPos3sMESA_remap_index 119
+#define WindowPos3svMESA_remap_index 120
+#define WindowPos4dMESA_remap_index 121
+#define WindowPos4dvMESA_remap_index 122
+#define WindowPos4fMESA_remap_index 123
+#define WindowPos4fvMESA_remap_index 124
+#define WindowPos4iMESA_remap_index 125
+#define WindowPos4ivMESA_remap_index 126
+#define WindowPos4sMESA_remap_index 127
+#define WindowPos4svMESA_remap_index 128
+#define BlendFuncSeparateEXT_remap_index 129
+#define IndexMaterialEXT_remap_index 130
+#define IndexFuncEXT_remap_index 131
+#define LockArraysEXT_remap_index 132
+#define UnlockArraysEXT_remap_index 133
+#define CullParameterdvEXT_remap_index 134
+#define CullParameterfvEXT_remap_index 135
+#define HintPGI_remap_index 136
+#define FogCoordfEXT_remap_index 137
+#define FogCoordfvEXT_remap_index 138
+#define FogCoorddEXT_remap_index 139
+#define FogCoorddvEXT_remap_index 140
+#define FogCoordPointerEXT_remap_index 141
+#define GetColorTableEXT_remap_index 142
+#define GetColorTableParameterivEXT_remap_index 143
+#define GetColorTableParameterfvEXT_remap_index 144
+#define TbufferMask3DFX_remap_index 145
+#define CompressedTexImage3DARB_remap_index 146
+#define CompressedTexImage2DARB_remap_index 147
+#define CompressedTexImage1DARB_remap_index 148
+#define CompressedTexSubImage3DARB_remap_index 149
+#define CompressedTexSubImage2DARB_remap_index 150
+#define CompressedTexSubImage1DARB_remap_index 151
+#define GetCompressedTexImageARB_remap_index 152
+#define SecondaryColor3bEXT_remap_index 153
+#define SecondaryColor3bvEXT_remap_index 154
+#define SecondaryColor3dEXT_remap_index 155
+#define SecondaryColor3dvEXT_remap_index 156
+#define SecondaryColor3fEXT_remap_index 157
+#define SecondaryColor3fvEXT_remap_index 158
+#define SecondaryColor3iEXT_remap_index 159
+#define SecondaryColor3ivEXT_remap_index 160
+#define SecondaryColor3sEXT_remap_index 161
+#define SecondaryColor3svEXT_remap_index 162
+#define SecondaryColor3ubEXT_remap_index 163
+#define SecondaryColor3ubvEXT_remap_index 164
+#define SecondaryColor3uiEXT_remap_index 165
+#define SecondaryColor3uivEXT_remap_index 166
+#define SecondaryColor3usEXT_remap_index 167
+#define SecondaryColor3usvEXT_remap_index 168
+#define SecondaryColorPointerEXT_remap_index 169
+#define AreProgramsResidentNV_remap_index 170
+#define BindProgramNV_remap_index 171
+#define DeleteProgramsNV_remap_index 172
+#define ExecuteProgramNV_remap_index 173
+#define GenProgramsNV_remap_index 174
+#define GetProgramParameterdvNV_remap_index 175
+#define GetProgramParameterfvNV_remap_index 176
+#define GetProgramivNV_remap_index 177
+#define GetProgramStringNV_remap_index 178
+#define GetTrackMatrixivNV_remap_index 179
+#define GetVertexAttribdvARB_remap_index 180
+#define GetVertexAttribfvARB_remap_index 181
+#define GetVertexAttribivARB_remap_index 182
+#define GetVertexAttribPointervNV_remap_index 183
+#define IsProgramNV_remap_index 184
+#define LoadProgramNV_remap_index 185
+#define ProgramParameter4dNV_remap_index 186
+#define ProgramParameter4dvNV_remap_index 187
+#define ProgramParameter4fNV_remap_index 188
+#define ProgramParameter4fvNV_remap_index 189
+#define ProgramParameters4dvNV_remap_index 190
+#define ProgramParameters4fvNV_remap_index 191
+#define RequestResidentProgramsNV_remap_index 192
+#define TrackMatrixNV_remap_index 193
+#define VertexAttribPointerNV_remap_index 194
+#define VertexAttrib1dARB_remap_index 195
+#define VertexAttrib1dvARB_remap_index 196
+#define VertexAttrib1fARB_remap_index 197
+#define VertexAttrib1fvARB_remap_index 198
+#define VertexAttrib1sARB_remap_index 199
+#define VertexAttrib1svARB_remap_index 200
+#define VertexAttrib2dARB_remap_index 201
+#define VertexAttrib2dvARB_remap_index 202
+#define VertexAttrib2fARB_remap_index 203
+#define VertexAttrib2fvARB_remap_index 204
+#define VertexAttrib2sARB_remap_index 205
+#define VertexAttrib2svARB_remap_index 206
+#define VertexAttrib3dARB_remap_index 207
+#define VertexAttrib3dvARB_remap_index 208
+#define VertexAttrib3fARB_remap_index 209
+#define VertexAttrib3fvARB_remap_index 210
+#define VertexAttrib3sARB_remap_index 211
+#define VertexAttrib3svARB_remap_index 212
+#define VertexAttrib4dARB_remap_index 213
+#define VertexAttrib4dvARB_remap_index 214
+#define VertexAttrib4fARB_remap_index 215
+#define VertexAttrib4fvARB_remap_index 216
+#define VertexAttrib4sARB_remap_index 217
+#define VertexAttrib4svARB_remap_index 218
+#define VertexAttrib4NubARB_remap_index 219
+#define VertexAttrib4NubvARB_remap_index 220
+#define VertexAttribs1dvNV_remap_index 221
+#define VertexAttribs1fvNV_remap_index 222
+#define VertexAttribs1svNV_remap_index 223
+#define VertexAttribs2dvNV_remap_index 224
+#define VertexAttribs2fvNV_remap_index 225
+#define VertexAttribs2svNV_remap_index 226
+#define VertexAttribs3dvNV_remap_index 227
+#define VertexAttribs3fvNV_remap_index 228
+#define VertexAttribs3svNV_remap_index 229
+#define VertexAttribs4dvNV_remap_index 230
+#define VertexAttribs4fvNV_remap_index 231
+#define VertexAttribs4svNV_remap_index 232
+#define VertexAttribs4ubvNV_remap_index 233
+#define PointParameteriNV_remap_index 234
+#define PointParameterivNV_remap_index 235
+#define MultiDrawArraysEXT_remap_index 236
+#define MultiDrawElementsEXT_remap_index 237
+#define ActiveStencilFaceEXT_remap_index 238
+#define DeleteFencesNV_remap_index 239
+#define GenFencesNV_remap_index 240
+#define IsFenceNV_remap_index 241
+#define TestFenceNV_remap_index 242
+#define GetFenceivNV_remap_index 243
+#define FinishFenceNV_remap_index 244
+#define SetFenceNV_remap_index 245
+#define VertexAttrib4bvARB_remap_index 246
+#define VertexAttrib4ivARB_remap_index 247
+#define VertexAttrib4ubvARB_remap_index 248
+#define VertexAttrib4usvARB_remap_index 249
+#define VertexAttrib4uivARB_remap_index 250
+#define VertexAttrib4NbvARB_remap_index 251
+#define VertexAttrib4NsvARB_remap_index 252
+#define VertexAttrib4NivARB_remap_index 253
+#define VertexAttrib4NusvARB_remap_index 254
+#define VertexAttrib4NuivARB_remap_index 255
+#define VertexAttribPointerARB_remap_index 256
+#define EnableVertexAttribArrayARB_remap_index 257
+#define DisableVertexAttribArrayARB_remap_index 258
+#define ProgramStringARB_remap_index 259
+#define ProgramEnvParameter4dARB_remap_index 260
+#define ProgramEnvParameter4dvARB_remap_index 261
+#define ProgramEnvParameter4fARB_remap_index 262
+#define ProgramEnvParameter4fvARB_remap_index 263
+#define ProgramLocalParameter4dARB_remap_index 264
+#define ProgramLocalParameter4dvARB_remap_index 265
+#define ProgramLocalParameter4fARB_remap_index 266
+#define ProgramLocalParameter4fvARB_remap_index 267
+#define GetProgramEnvParameterdvARB_remap_index 268
+#define GetProgramEnvParameterfvARB_remap_index 269
+#define GetProgramLocalParameterdvARB_remap_index 270
+#define GetProgramLocalParameterfvARB_remap_index 271
+#define GetProgramivARB_remap_index 272
+#define GetProgramStringARB_remap_index 273
+#define ProgramNamedParameter4fNV_remap_index 274
+#define ProgramNamedParameter4dNV_remap_index 275
+#define ProgramNamedParameter4fvNV_remap_index 276
+#define ProgramNamedParameter4dvNV_remap_index 277
+#define GetProgramNamedParameterfvNV_remap_index 278
+#define GetProgramNamedParameterdvNV_remap_index 279
+#define BindBufferARB_remap_index 280
+#define BufferDataARB_remap_index 281
+#define BufferSubDataARB_remap_index 282
+#define DeleteBuffersARB_remap_index 283
+#define GenBuffersARB_remap_index 284
+#define GetBufferParameterivARB_remap_index 285
+#define GetBufferPointervARB_remap_index 286
+#define GetBufferSubDataARB_remap_index 287
+#define IsBufferARB_remap_index 288
+#define MapBufferARB_remap_index 289
+#define UnmapBufferARB_remap_index 290
+#define DepthBoundsEXT_remap_index 291
+#define GenQueriesARB_remap_index 292
+#define DeleteQueriesARB_remap_index 293
+#define IsQueryARB_remap_index 294
+#define BeginQueryARB_remap_index 295
+#define EndQueryARB_remap_index 296
+#define GetQueryivARB_remap_index 297
+#define GetQueryObjectivARB_remap_index 298
+#define GetQueryObjectuivARB_remap_index 299
+#define MultiModeDrawArraysIBM_remap_index 300
+#define MultiModeDrawElementsIBM_remap_index 301
+#define BlendEquationSeparateEXT_remap_index 302
+#define DeleteObjectARB_remap_index 303
+#define GetHandleARB_remap_index 304
+#define DetachObjectARB_remap_index 305
+#define CreateShaderObjectARB_remap_index 306
+#define ShaderSourceARB_remap_index 307
+#define CompileShaderARB_remap_index 308
+#define CreateProgramObjectARB_remap_index 309
+#define AttachObjectARB_remap_index 310
+#define LinkProgramARB_remap_index 311
+#define UseProgramObjectARB_remap_index 312
+#define ValidateProgramARB_remap_index 313
+#define Uniform1fARB_remap_index 314
+#define Uniform2fARB_remap_index 315
+#define Uniform3fARB_remap_index 316
+#define Uniform4fARB_remap_index 317
+#define Uniform1iARB_remap_index 318
+#define Uniform2iARB_remap_index 319
+#define Uniform3iARB_remap_index 320
+#define Uniform4iARB_remap_index 321
+#define Uniform1fvARB_remap_index 322
+#define Uniform2fvARB_remap_index 323
+#define Uniform3fvARB_remap_index 324
+#define Uniform4fvARB_remap_index 325
+#define Uniform1ivARB_remap_index 326
+#define Uniform2ivARB_remap_index 327
+#define Uniform3ivARB_remap_index 328
+#define Uniform4ivARB_remap_index 329
+#define UniformMatrix2fvARB_remap_index 330
+#define UniformMatrix3fvARB_remap_index 331
+#define UniformMatrix4fvARB_remap_index 332
+#define GetObjectParameterfvARB_remap_index 333
+#define GetObjectParameterivARB_remap_index 334
+#define GetInfoLogARB_remap_index 335
+#define GetAttachedObjectsARB_remap_index 336
+#define GetUniformLocationARB_remap_index 337
+#define GetActiveUniformARB_remap_index 338
+#define GetUniformfvARB_remap_index 339
+#define GetUniformivARB_remap_index 340
+#define GetShaderSourceARB_remap_index 341
+#define BindAttribLocationARB_remap_index 342
+#define GetActiveAttribARB_remap_index 343
+#define GetAttribLocationARB_remap_index 344
+#define GetVertexAttribdvNV_remap_index 345
+#define GetVertexAttribfvNV_remap_index 346
+#define GetVertexAttribivNV_remap_index 347
+#define VertexAttrib1dNV_remap_index 348
+#define VertexAttrib1dvNV_remap_index 349
+#define VertexAttrib1fNV_remap_index 350
+#define VertexAttrib1fvNV_remap_index 351
+#define VertexAttrib1sNV_remap_index 352
+#define VertexAttrib1svNV_remap_index 353
+#define VertexAttrib2dNV_remap_index 354
+#define VertexAttrib2dvNV_remap_index 355
+#define VertexAttrib2fNV_remap_index 356
+#define VertexAttrib2fvNV_remap_index 357
+#define VertexAttrib2sNV_remap_index 358
+#define VertexAttrib2svNV_remap_index 359
+#define VertexAttrib3dNV_remap_index 360
+#define VertexAttrib3dvNV_remap_index 361
+#define VertexAttrib3fNV_remap_index 362
+#define VertexAttrib3fvNV_remap_index 363
+#define VertexAttrib3sNV_remap_index 364
+#define VertexAttrib3svNV_remap_index 365
+#define VertexAttrib4dNV_remap_index 366
+#define VertexAttrib4dvNV_remap_index 367
+#define VertexAttrib4fNV_remap_index 368
+#define VertexAttrib4fvNV_remap_index 369
+#define VertexAttrib4sNV_remap_index 370
+#define VertexAttrib4svNV_remap_index 371
+#define VertexAttrib4ubNV_remap_index 372
+#define VertexAttrib4ubvNV_remap_index 373
+#define GenFragmentShadersATI_remap_index 374
+#define BindFragmentShaderATI_remap_index 375
+#define DeleteFragmentShaderATI_remap_index 376
+#define BeginFragmentShaderATI_remap_index 377
+#define EndFragmentShaderATI_remap_index 378
+#define PassTexCoordATI_remap_index 379
+#define SampleMapATI_remap_index 380
+#define ColorFragmentOp1ATI_remap_index 381
+#define ColorFragmentOp2ATI_remap_index 382
+#define ColorFragmentOp3ATI_remap_index 383
+#define AlphaFragmentOp1ATI_remap_index 384
+#define AlphaFragmentOp2ATI_remap_index 385
+#define AlphaFragmentOp3ATI_remap_index 386
+#define SetFragmentShaderConstantATI_remap_index 387
+#define IsRenderbufferEXT_remap_index 388
+#define BindRenderbufferEXT_remap_index 389
+#define DeleteRenderbuffersEXT_remap_index 390
+#define GenRenderbuffersEXT_remap_index 391
+#define RenderbufferStorageEXT_remap_index 392
+#define GetRenderbufferParameterivEXT_remap_index 393
+#define IsFramebufferEXT_remap_index 394
+#define BindFramebufferEXT_remap_index 395
+#define DeleteFramebuffersEXT_remap_index 396
+#define GenFramebuffersEXT_remap_index 397
+#define CheckFramebufferStatusEXT_remap_index 398
+#define FramebufferTexture1DEXT_remap_index 399
+#define FramebufferTexture2DEXT_remap_index 400
+#define FramebufferTexture3DEXT_remap_index 401
+#define FramebufferRenderbufferEXT_remap_index 402
+#define GetFramebufferAttachmentParameterivEXT_remap_index 403
+#define GenerateMipmapEXT_remap_index 404
+#define StencilFuncSeparate_remap_index 405
+#define StencilOpSeparate_remap_index 406
+#define StencilMaskSeparate_remap_index 407
+
+#define CALL_LoadTransposeMatrixfARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index], parameters)
+#define GET_LoadTransposeMatrixfARB(disp) GET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index])
+#define SET_LoadTransposeMatrixfARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index], fn)
+#define CALL_LoadTransposeMatrixdARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index], parameters)
+#define GET_LoadTransposeMatrixdARB(disp) GET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index])
+#define SET_LoadTransposeMatrixdARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index], fn)
+#define CALL_MultTransposeMatrixfARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[MultTransposeMatrixfARB_remap_index], parameters)
+#define GET_MultTransposeMatrixfARB(disp) GET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixfARB_remap_index])
+#define SET_MultTransposeMatrixfARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixfARB_remap_index], fn)
+#define CALL_MultTransposeMatrixdARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[MultTransposeMatrixdARB_remap_index], parameters)
+#define GET_MultTransposeMatrixdARB(disp) GET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixdARB_remap_index])
+#define SET_MultTransposeMatrixdARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixdARB_remap_index], fn)
+#define CALL_SampleCoverageARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLboolean)), driDispatchRemapTable[SampleCoverageARB_remap_index], parameters)
+#define GET_SampleCoverageARB(disp) GET_by_offset(disp, driDispatchRemapTable[SampleCoverageARB_remap_index])
+#define SET_SampleCoverageARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SampleCoverageARB_remap_index], fn)
+#define CALL_DrawBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLenum *)), driDispatchRemapTable[DrawBuffersARB_remap_index], parameters)
+#define GET_DrawBuffersARB(disp) GET_by_offset(disp, driDispatchRemapTable[DrawBuffersARB_remap_index])
+#define SET_DrawBuffersARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawBuffersARB_remap_index], fn)
+#define CALL_PolygonOffsetEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), driDispatchRemapTable[PolygonOffsetEXT_remap_index], parameters)
+#define GET_PolygonOffsetEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index])
+#define SET_PolygonOffsetEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index], fn)
+#define CALL_GetTexFilterFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetTexFilterFuncSGIS_remap_index], parameters)
+#define GET_GetTexFilterFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetTexFilterFuncSGIS_remap_index])
+#define SET_GetTexFilterFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetTexFilterFuncSGIS_remap_index], fn)
+#define CALL_TexFilterFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, const GLfloat *)), driDispatchRemapTable[TexFilterFuncSGIS_remap_index], parameters)
+#define GET_TexFilterFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[TexFilterFuncSGIS_remap_index])
+#define SET_TexFilterFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexFilterFuncSGIS_remap_index], fn)
+#define CALL_GetHistogramEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetHistogramEXT_remap_index], parameters)
+#define GET_GetHistogramEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetHistogramEXT_remap_index])
+#define SET_GetHistogramEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHistogramEXT_remap_index], fn)
+#define CALL_GetHistogramParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetHistogramParameterfvEXT_remap_index], parameters)
+#define GET_GetHistogramParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterfvEXT_remap_index])
+#define SET_GetHistogramParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterfvEXT_remap_index], fn)
+#define CALL_GetHistogramParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetHistogramParameterivEXT_remap_index], parameters)
+#define GET_GetHistogramParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterivEXT_remap_index])
+#define SET_GetHistogramParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterivEXT_remap_index], fn)
+#define CALL_GetMinmaxEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetMinmaxEXT_remap_index], parameters)
+#define GET_GetMinmaxEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetMinmaxEXT_remap_index])
+#define SET_GetMinmaxEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetMinmaxEXT_remap_index], fn)
+#define CALL_GetMinmaxParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetMinmaxParameterfvEXT_remap_index], parameters)
+#define GET_GetMinmaxParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterfvEXT_remap_index])
+#define SET_GetMinmaxParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterfvEXT_remap_index], fn)
+#define CALL_GetMinmaxParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetMinmaxParameterivEXT_remap_index], parameters)
+#define GET_GetMinmaxParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterivEXT_remap_index])
+#define SET_GetMinmaxParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterivEXT_remap_index], fn)
+#define CALL_GetConvolutionFilterEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetConvolutionFilterEXT_remap_index], parameters)
+#define GET_GetConvolutionFilterEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetConvolutionFilterEXT_remap_index])
+#define SET_GetConvolutionFilterEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetConvolutionFilterEXT_remap_index], fn)
+#define CALL_GetConvolutionParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetConvolutionParameterfvEXT_remap_index], parameters)
+#define GET_GetConvolutionParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterfvEXT_remap_index])
+#define SET_GetConvolutionParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterfvEXT_remap_index], fn)
+#define CALL_GetConvolutionParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetConvolutionParameterivEXT_remap_index], parameters)
+#define GET_GetConvolutionParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterivEXT_remap_index])
+#define SET_GetConvolutionParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterivEXT_remap_index], fn)
+#define CALL_GetSeparableFilterEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *)), driDispatchRemapTable[GetSeparableFilterEXT_remap_index], parameters)
+#define GET_GetSeparableFilterEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetSeparableFilterEXT_remap_index])
+#define SET_GetSeparableFilterEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetSeparableFilterEXT_remap_index], fn)
+#define CALL_GetColorTableSGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetColorTableSGI_remap_index], parameters)
+#define GET_GetColorTableSGI(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableSGI_remap_index])
+#define SET_GetColorTableSGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableSGI_remap_index], fn)
+#define CALL_GetColorTableParameterfvSGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetColorTableParameterfvSGI_remap_index], parameters)
+#define GET_GetColorTableParameterfvSGI(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvSGI_remap_index])
+#define SET_GetColorTableParameterfvSGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvSGI_remap_index], fn)
+#define CALL_GetColorTableParameterivSGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetColorTableParameterivSGI_remap_index], parameters)
+#define GET_GetColorTableParameterivSGI(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivSGI_remap_index])
+#define SET_GetColorTableParameterivSGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivSGI_remap_index], fn)
+#define CALL_PixelTexGenSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[PixelTexGenSGIX_remap_index], parameters)
+#define GET_PixelTexGenSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenSGIX_remap_index])
+#define SET_PixelTexGenSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenSGIX_remap_index], fn)
+#define CALL_PixelTexGenParameteriSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[PixelTexGenParameteriSGIS_remap_index], parameters)
+#define GET_PixelTexGenParameteriSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameteriSGIS_remap_index])
+#define SET_PixelTexGenParameteriSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameteriSGIS_remap_index], fn)
+#define CALL_PixelTexGenParameterivSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[PixelTexGenParameterivSGIS_remap_index], parameters)
+#define GET_PixelTexGenParameterivSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterivSGIS_remap_index])
+#define SET_PixelTexGenParameterivSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterivSGIS_remap_index], fn)
+#define CALL_PixelTexGenParameterfSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[PixelTexGenParameterfSGIS_remap_index], parameters)
+#define GET_PixelTexGenParameterfSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfSGIS_remap_index])
+#define SET_PixelTexGenParameterfSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfSGIS_remap_index], fn)
+#define CALL_PixelTexGenParameterfvSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[PixelTexGenParameterfvSGIS_remap_index], parameters)
+#define GET_PixelTexGenParameterfvSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfvSGIS_remap_index])
+#define SET_PixelTexGenParameterfvSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfvSGIS_remap_index], fn)
+#define CALL_GetPixelTexGenParameterivSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint *)), driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index], parameters)
+#define GET_GetPixelTexGenParameterivSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index])
+#define SET_GetPixelTexGenParameterivSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index], fn)
+#define CALL_GetPixelTexGenParameterfvSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index], parameters)
+#define GET_GetPixelTexGenParameterfvSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index])
+#define SET_GetPixelTexGenParameterfvSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index], fn)
+#define CALL_TexImage4DSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), driDispatchRemapTable[TexImage4DSGIS_remap_index], parameters)
+#define GET_TexImage4DSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[TexImage4DSGIS_remap_index])
+#define SET_TexImage4DSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexImage4DSGIS_remap_index], fn)
+#define CALL_TexSubImage4DSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), driDispatchRemapTable[TexSubImage4DSGIS_remap_index], parameters)
+#define GET_TexSubImage4DSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[TexSubImage4DSGIS_remap_index])
+#define SET_TexSubImage4DSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexSubImage4DSGIS_remap_index], fn)
+#define CALL_AreTexturesResidentEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLsizei, const GLuint *, GLboolean *)), driDispatchRemapTable[AreTexturesResidentEXT_remap_index], parameters)
+#define GET_AreTexturesResidentEXT(disp) GET_by_offset(disp, driDispatchRemapTable[AreTexturesResidentEXT_remap_index])
+#define SET_AreTexturesResidentEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AreTexturesResidentEXT_remap_index], fn)
+#define CALL_GenTexturesEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenTexturesEXT_remap_index], parameters)
+#define GET_GenTexturesEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenTexturesEXT_remap_index])
+#define SET_GenTexturesEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenTexturesEXT_remap_index], fn)
+#define CALL_IsTextureEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsTextureEXT_remap_index], parameters)
+#define GET_IsTextureEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IsTextureEXT_remap_index])
+#define SET_IsTextureEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsTextureEXT_remap_index], fn)
+#define CALL_DetailTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLfloat *)), driDispatchRemapTable[DetailTexFuncSGIS_remap_index], parameters)
+#define GET_DetailTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[DetailTexFuncSGIS_remap_index])
+#define SET_DetailTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DetailTexFuncSGIS_remap_index], fn)
+#define CALL_GetDetailTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[GetDetailTexFuncSGIS_remap_index], parameters)
+#define GET_GetDetailTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetDetailTexFuncSGIS_remap_index])
+#define SET_GetDetailTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetDetailTexFuncSGIS_remap_index], fn)
+#define CALL_SharpenTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLfloat *)), driDispatchRemapTable[SharpenTexFuncSGIS_remap_index], parameters)
+#define GET_SharpenTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[SharpenTexFuncSGIS_remap_index])
+#define SET_SharpenTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SharpenTexFuncSGIS_remap_index], fn)
+#define CALL_GetSharpenTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[GetSharpenTexFuncSGIS_remap_index], parameters)
+#define GET_GetSharpenTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetSharpenTexFuncSGIS_remap_index])
+#define SET_GetSharpenTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetSharpenTexFuncSGIS_remap_index], fn)
+#define CALL_SampleMaskSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLboolean)), driDispatchRemapTable[SampleMaskSGIS_remap_index], parameters)
+#define GET_SampleMaskSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[SampleMaskSGIS_remap_index])
+#define SET_SampleMaskSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SampleMaskSGIS_remap_index], fn)
+#define CALL_SamplePatternSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[SamplePatternSGIS_remap_index], parameters)
+#define GET_SamplePatternSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[SamplePatternSGIS_remap_index])
+#define SET_SamplePatternSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SamplePatternSGIS_remap_index], fn)
+#define CALL_ColorPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[ColorPointerEXT_remap_index], parameters)
+#define GET_ColorPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[ColorPointerEXT_remap_index])
+#define SET_ColorPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorPointerEXT_remap_index], fn)
+#define CALL_EdgeFlagPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLsizei, const GLboolean *)), driDispatchRemapTable[EdgeFlagPointerEXT_remap_index], parameters)
+#define GET_EdgeFlagPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[EdgeFlagPointerEXT_remap_index])
+#define SET_EdgeFlagPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EdgeFlagPointerEXT_remap_index], fn)
+#define CALL_IndexPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[IndexPointerEXT_remap_index], parameters)
+#define GET_IndexPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IndexPointerEXT_remap_index])
+#define SET_IndexPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IndexPointerEXT_remap_index], fn)
+#define CALL_NormalPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[NormalPointerEXT_remap_index], parameters)
+#define GET_NormalPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[NormalPointerEXT_remap_index])
+#define SET_NormalPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[NormalPointerEXT_remap_index], fn)
+#define CALL_TexCoordPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[TexCoordPointerEXT_remap_index], parameters)
+#define GET_TexCoordPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[TexCoordPointerEXT_remap_index])
+#define SET_TexCoordPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexCoordPointerEXT_remap_index], fn)
+#define CALL_VertexPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexPointerEXT_remap_index], parameters)
+#define GET_VertexPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexPointerEXT_remap_index])
+#define SET_VertexPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexPointerEXT_remap_index], fn)
+#define CALL_SpriteParameterfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[SpriteParameterfSGIX_remap_index], parameters)
+#define GET_SpriteParameterfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameterfSGIX_remap_index])
+#define SET_SpriteParameterfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameterfSGIX_remap_index], fn)
+#define CALL_SpriteParameterfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[SpriteParameterfvSGIX_remap_index], parameters)
+#define GET_SpriteParameterfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameterfvSGIX_remap_index])
+#define SET_SpriteParameterfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameterfvSGIX_remap_index], fn)
+#define CALL_SpriteParameteriSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[SpriteParameteriSGIX_remap_index], parameters)
+#define GET_SpriteParameteriSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameteriSGIX_remap_index])
+#define SET_SpriteParameteriSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameteriSGIX_remap_index], fn)
+#define CALL_SpriteParameterivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[SpriteParameterivSGIX_remap_index], parameters)
+#define GET_SpriteParameterivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameterivSGIX_remap_index])
+#define SET_SpriteParameterivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameterivSGIX_remap_index], fn)
+#define CALL_PointParameterfEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[PointParameterfEXT_remap_index], parameters)
+#define GET_PointParameterfEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameterfEXT_remap_index])
+#define SET_PointParameterfEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameterfEXT_remap_index], fn)
+#define CALL_PointParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[PointParameterfvEXT_remap_index], parameters)
+#define GET_PointParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameterfvEXT_remap_index])
+#define SET_PointParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameterfvEXT_remap_index], fn)
+#define CALL_GetInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(void)), driDispatchRemapTable[GetInstrumentsSGIX_remap_index], parameters)
+#define GET_GetInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetInstrumentsSGIX_remap_index])
+#define SET_GetInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetInstrumentsSGIX_remap_index], fn)
+#define CALL_InstrumentsBufferSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLint *)), driDispatchRemapTable[InstrumentsBufferSGIX_remap_index], parameters)
+#define GET_InstrumentsBufferSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[InstrumentsBufferSGIX_remap_index])
+#define SET_InstrumentsBufferSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[InstrumentsBufferSGIX_remap_index], fn)
+#define CALL_PollInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLint *)), driDispatchRemapTable[PollInstrumentsSGIX_remap_index], parameters)
+#define GET_PollInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[PollInstrumentsSGIX_remap_index])
+#define SET_PollInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PollInstrumentsSGIX_remap_index], fn)
+#define CALL_ReadInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), driDispatchRemapTable[ReadInstrumentsSGIX_remap_index], parameters)
+#define GET_ReadInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ReadInstrumentsSGIX_remap_index])
+#define SET_ReadInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ReadInstrumentsSGIX_remap_index], fn)
+#define CALL_StartInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[StartInstrumentsSGIX_remap_index], parameters)
+#define GET_StartInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[StartInstrumentsSGIX_remap_index])
+#define SET_StartInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StartInstrumentsSGIX_remap_index], fn)
+#define CALL_StopInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), driDispatchRemapTable[StopInstrumentsSGIX_remap_index], parameters)
+#define GET_StopInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[StopInstrumentsSGIX_remap_index])
+#define SET_StopInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StopInstrumentsSGIX_remap_index], fn)
+#define CALL_FrameZoomSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), driDispatchRemapTable[FrameZoomSGIX_remap_index], parameters)
+#define GET_FrameZoomSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FrameZoomSGIX_remap_index])
+#define SET_FrameZoomSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FrameZoomSGIX_remap_index], fn)
+#define CALL_TagSampleBufferSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[TagSampleBufferSGIX_remap_index], parameters)
+#define GET_TagSampleBufferSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[TagSampleBufferSGIX_remap_index])
+#define SET_TagSampleBufferSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TagSampleBufferSGIX_remap_index], fn)
+#define CALL_ReferencePlaneSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[ReferencePlaneSGIX_remap_index], parameters)
+#define GET_ReferencePlaneSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ReferencePlaneSGIX_remap_index])
+#define SET_ReferencePlaneSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ReferencePlaneSGIX_remap_index], fn)
+#define CALL_FlushRasterSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[FlushRasterSGIX_remap_index], parameters)
+#define GET_FlushRasterSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FlushRasterSGIX_remap_index])
+#define SET_FlushRasterSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FlushRasterSGIX_remap_index], fn)
+#define CALL_GetListParameterfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetListParameterfvSGIX_remap_index], parameters)
+#define GET_GetListParameterfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetListParameterfvSGIX_remap_index])
+#define SET_GetListParameterfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetListParameterfvSGIX_remap_index], fn)
+#define CALL_GetListParameterivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetListParameterivSGIX_remap_index], parameters)
+#define GET_GetListParameterivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetListParameterivSGIX_remap_index])
+#define SET_GetListParameterivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetListParameterivSGIX_remap_index], fn)
+#define CALL_ListParameterfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat)), driDispatchRemapTable[ListParameterfSGIX_remap_index], parameters)
+#define GET_ListParameterfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameterfSGIX_remap_index])
+#define SET_ListParameterfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameterfSGIX_remap_index], fn)
+#define CALL_ListParameterfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, const GLfloat *)), driDispatchRemapTable[ListParameterfvSGIX_remap_index], parameters)
+#define GET_ListParameterfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameterfvSGIX_remap_index])
+#define SET_ListParameterfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameterfvSGIX_remap_index], fn)
+#define CALL_ListParameteriSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint)), driDispatchRemapTable[ListParameteriSGIX_remap_index], parameters)
+#define GET_ListParameteriSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameteriSGIX_remap_index])
+#define SET_ListParameteriSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameteriSGIX_remap_index], fn)
+#define CALL_ListParameterivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, const GLint *)), driDispatchRemapTable[ListParameterivSGIX_remap_index], parameters)
+#define GET_ListParameterivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameterivSGIX_remap_index])
+#define SET_ListParameterivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameterivSGIX_remap_index], fn)
+#define CALL_FragmentColorMaterialSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[FragmentColorMaterialSGIX_remap_index], parameters)
+#define GET_FragmentColorMaterialSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentColorMaterialSGIX_remap_index])
+#define SET_FragmentColorMaterialSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentColorMaterialSGIX_remap_index], fn)
+#define CALL_FragmentLightfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), driDispatchRemapTable[FragmentLightfSGIX_remap_index], parameters)
+#define GET_FragmentLightfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightfSGIX_remap_index])
+#define SET_FragmentLightfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightfSGIX_remap_index], fn)
+#define CALL_FragmentLightfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), driDispatchRemapTable[FragmentLightfvSGIX_remap_index], parameters)
+#define GET_FragmentLightfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightfvSGIX_remap_index])
+#define SET_FragmentLightfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightfvSGIX_remap_index], fn)
+#define CALL_FragmentLightiSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), driDispatchRemapTable[FragmentLightiSGIX_remap_index], parameters)
+#define GET_FragmentLightiSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightiSGIX_remap_index])
+#define SET_FragmentLightiSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightiSGIX_remap_index], fn)
+#define CALL_FragmentLightivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), driDispatchRemapTable[FragmentLightivSGIX_remap_index], parameters)
+#define GET_FragmentLightivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightivSGIX_remap_index])
+#define SET_FragmentLightivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightivSGIX_remap_index], fn)
+#define CALL_FragmentLightModelfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[FragmentLightModelfSGIX_remap_index], parameters)
+#define GET_FragmentLightModelfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfSGIX_remap_index])
+#define SET_FragmentLightModelfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfSGIX_remap_index], fn)
+#define CALL_FragmentLightModelfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[FragmentLightModelfvSGIX_remap_index], parameters)
+#define GET_FragmentLightModelfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfvSGIX_remap_index])
+#define SET_FragmentLightModelfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfvSGIX_remap_index], fn)
+#define CALL_FragmentLightModeliSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[FragmentLightModeliSGIX_remap_index], parameters)
+#define GET_FragmentLightModeliSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModeliSGIX_remap_index])
+#define SET_FragmentLightModeliSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModeliSGIX_remap_index], fn)
+#define CALL_FragmentLightModelivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[FragmentLightModelivSGIX_remap_index], parameters)
+#define GET_FragmentLightModelivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModelivSGIX_remap_index])
+#define SET_FragmentLightModelivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModelivSGIX_remap_index], fn)
+#define CALL_FragmentMaterialfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), driDispatchRemapTable[FragmentMaterialfSGIX_remap_index], parameters)
+#define GET_FragmentMaterialfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfSGIX_remap_index])
+#define SET_FragmentMaterialfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfSGIX_remap_index], fn)
+#define CALL_FragmentMaterialfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), driDispatchRemapTable[FragmentMaterialfvSGIX_remap_index], parameters)
+#define GET_FragmentMaterialfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfvSGIX_remap_index])
+#define SET_FragmentMaterialfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfvSGIX_remap_index], fn)
+#define CALL_FragmentMaterialiSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), driDispatchRemapTable[FragmentMaterialiSGIX_remap_index], parameters)
+#define GET_FragmentMaterialiSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialiSGIX_remap_index])
+#define SET_FragmentMaterialiSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialiSGIX_remap_index], fn)
+#define CALL_FragmentMaterialivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), driDispatchRemapTable[FragmentMaterialivSGIX_remap_index], parameters)
+#define GET_FragmentMaterialivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialivSGIX_remap_index])
+#define SET_FragmentMaterialivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialivSGIX_remap_index], fn)
+#define CALL_GetFragmentLightfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetFragmentLightfvSGIX_remap_index], parameters)
+#define GET_GetFragmentLightfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentLightfvSGIX_remap_index])
+#define SET_GetFragmentLightfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentLightfvSGIX_remap_index], fn)
+#define CALL_GetFragmentLightivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFragmentLightivSGIX_remap_index], parameters)
+#define GET_GetFragmentLightivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentLightivSGIX_remap_index])
+#define SET_GetFragmentLightivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentLightivSGIX_remap_index], fn)
+#define CALL_GetFragmentMaterialfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetFragmentMaterialfvSGIX_remap_index], parameters)
+#define GET_GetFragmentMaterialfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialfvSGIX_remap_index])
+#define SET_GetFragmentMaterialfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialfvSGIX_remap_index], fn)
+#define CALL_GetFragmentMaterialivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFragmentMaterialivSGIX_remap_index], parameters)
+#define GET_GetFragmentMaterialivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialivSGIX_remap_index])
+#define SET_GetFragmentMaterialivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialivSGIX_remap_index], fn)
+#define CALL_LightEnviSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[LightEnviSGIX_remap_index], parameters)
+#define GET_LightEnviSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[LightEnviSGIX_remap_index])
+#define SET_LightEnviSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LightEnviSGIX_remap_index], fn)
+#define CALL_VertexWeightfEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), driDispatchRemapTable[VertexWeightfEXT_remap_index], parameters)
+#define GET_VertexWeightfEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexWeightfEXT_remap_index])
+#define SET_VertexWeightfEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexWeightfEXT_remap_index], fn)
+#define CALL_VertexWeightfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[VertexWeightfvEXT_remap_index], parameters)
+#define GET_VertexWeightfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexWeightfvEXT_remap_index])
+#define SET_VertexWeightfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexWeightfvEXT_remap_index], fn)
+#define CALL_VertexWeightPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexWeightPointerEXT_remap_index], parameters)
+#define GET_VertexWeightPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexWeightPointerEXT_remap_index])
+#define SET_VertexWeightPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexWeightPointerEXT_remap_index], fn)
+#define CALL_FlushVertexArrayRangeNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[FlushVertexArrayRangeNV_remap_index], parameters)
+#define GET_FlushVertexArrayRangeNV(disp) GET_by_offset(disp, driDispatchRemapTable[FlushVertexArrayRangeNV_remap_index])
+#define SET_FlushVertexArrayRangeNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FlushVertexArrayRangeNV_remap_index], fn)
+#define CALL_VertexArrayRangeNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLvoid *)), driDispatchRemapTable[VertexArrayRangeNV_remap_index], parameters)
+#define GET_VertexArrayRangeNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexArrayRangeNV_remap_index])
+#define SET_VertexArrayRangeNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexArrayRangeNV_remap_index], fn)
+#define CALL_CombinerParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[CombinerParameterfvNV_remap_index], parameters)
+#define GET_CombinerParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameterfvNV_remap_index])
+#define SET_CombinerParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameterfvNV_remap_index], fn)
+#define CALL_CombinerParameterfNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[CombinerParameterfNV_remap_index], parameters)
+#define GET_CombinerParameterfNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameterfNV_remap_index])
+#define SET_CombinerParameterfNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameterfNV_remap_index], fn)
+#define CALL_CombinerParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[CombinerParameterivNV_remap_index], parameters)
+#define GET_CombinerParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameterivNV_remap_index])
+#define SET_CombinerParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameterivNV_remap_index], fn)
+#define CALL_CombinerParameteriNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[CombinerParameteriNV_remap_index], parameters)
+#define GET_CombinerParameteriNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameteriNV_remap_index])
+#define SET_CombinerParameteriNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameteriNV_remap_index], fn)
+#define CALL_CombinerInputNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[CombinerInputNV_remap_index], parameters)
+#define GET_CombinerInputNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerInputNV_remap_index])
+#define SET_CombinerInputNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerInputNV_remap_index], fn)
+#define CALL_CombinerOutputNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean)), driDispatchRemapTable[CombinerOutputNV_remap_index], parameters)
+#define GET_CombinerOutputNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerOutputNV_remap_index])
+#define SET_CombinerOutputNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerOutputNV_remap_index], fn)
+#define CALL_FinalCombinerInputNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[FinalCombinerInputNV_remap_index], parameters)
+#define GET_FinalCombinerInputNV(disp) GET_by_offset(disp, driDispatchRemapTable[FinalCombinerInputNV_remap_index])
+#define SET_FinalCombinerInputNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FinalCombinerInputNV_remap_index], fn)
+#define CALL_GetCombinerInputParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetCombinerInputParameterfvNV_remap_index], parameters)
+#define GET_GetCombinerInputParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterfvNV_remap_index])
+#define SET_GetCombinerInputParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterfvNV_remap_index], fn)
+#define CALL_GetCombinerInputParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLint *)), driDispatchRemapTable[GetCombinerInputParameterivNV_remap_index], parameters)
+#define GET_GetCombinerInputParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterivNV_remap_index])
+#define SET_GetCombinerInputParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterivNV_remap_index], fn)
+#define CALL_GetCombinerOutputParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetCombinerOutputParameterfvNV_remap_index], parameters)
+#define GET_GetCombinerOutputParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterfvNV_remap_index])
+#define SET_GetCombinerOutputParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterfvNV_remap_index], fn)
+#define CALL_GetCombinerOutputParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLint *)), driDispatchRemapTable[GetCombinerOutputParameterivNV_remap_index], parameters)
+#define GET_GetCombinerOutputParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterivNV_remap_index])
+#define SET_GetCombinerOutputParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterivNV_remap_index], fn)
+#define CALL_GetFinalCombinerInputParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetFinalCombinerInputParameterfvNV_remap_index], parameters)
+#define GET_GetFinalCombinerInputParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterfvNV_remap_index])
+#define SET_GetFinalCombinerInputParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterfvNV_remap_index], fn)
+#define CALL_GetFinalCombinerInputParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFinalCombinerInputParameterivNV_remap_index], parameters)
+#define GET_GetFinalCombinerInputParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterivNV_remap_index])
+#define SET_GetFinalCombinerInputParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterivNV_remap_index], fn)
+#define CALL_ResizeBuffersMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[ResizeBuffersMESA_remap_index], parameters)
+#define GET_ResizeBuffersMESA(disp) GET_by_offset(disp, driDispatchRemapTable[ResizeBuffersMESA_remap_index])
+#define SET_ResizeBuffersMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ResizeBuffersMESA_remap_index], fn)
+#define CALL_WindowPos2dMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), driDispatchRemapTable[WindowPos2dMESA_remap_index], parameters)
+#define GET_WindowPos2dMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2dMESA_remap_index])
+#define SET_WindowPos2dMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2dMESA_remap_index], fn)
+#define CALL_WindowPos2dvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[WindowPos2dvMESA_remap_index], parameters)
+#define GET_WindowPos2dvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2dvMESA_remap_index])
+#define SET_WindowPos2dvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2dvMESA_remap_index], fn)
+#define CALL_WindowPos2fMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), driDispatchRemapTable[WindowPos2fMESA_remap_index], parameters)
+#define GET_WindowPos2fMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2fMESA_remap_index])
+#define SET_WindowPos2fMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2fMESA_remap_index], fn)
+#define CALL_WindowPos2fvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[WindowPos2fvMESA_remap_index], parameters)
+#define GET_WindowPos2fvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2fvMESA_remap_index])
+#define SET_WindowPos2fvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2fvMESA_remap_index], fn)
+#define CALL_WindowPos2iMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), driDispatchRemapTable[WindowPos2iMESA_remap_index], parameters)
+#define GET_WindowPos2iMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2iMESA_remap_index])
+#define SET_WindowPos2iMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2iMESA_remap_index], fn)
+#define CALL_WindowPos2ivMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[WindowPos2ivMESA_remap_index], parameters)
+#define GET_WindowPos2ivMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2ivMESA_remap_index])
+#define SET_WindowPos2ivMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2ivMESA_remap_index], fn)
+#define CALL_WindowPos2sMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), driDispatchRemapTable[WindowPos2sMESA_remap_index], parameters)
+#define GET_WindowPos2sMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2sMESA_remap_index])
+#define SET_WindowPos2sMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2sMESA_remap_index], fn)
+#define CALL_WindowPos2svMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[WindowPos2svMESA_remap_index], parameters)
+#define GET_WindowPos2svMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2svMESA_remap_index])
+#define SET_WindowPos2svMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2svMESA_remap_index], fn)
+#define CALL_WindowPos3dMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[WindowPos3dMESA_remap_index], parameters)
+#define GET_WindowPos3dMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3dMESA_remap_index])
+#define SET_WindowPos3dMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3dMESA_remap_index], fn)
+#define CALL_WindowPos3dvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[WindowPos3dvMESA_remap_index], parameters)
+#define GET_WindowPos3dvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3dvMESA_remap_index])
+#define SET_WindowPos3dvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3dvMESA_remap_index], fn)
+#define CALL_WindowPos3fMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[WindowPos3fMESA_remap_index], parameters)
+#define GET_WindowPos3fMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3fMESA_remap_index])
+#define SET_WindowPos3fMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3fMESA_remap_index], fn)
+#define CALL_WindowPos3fvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[WindowPos3fvMESA_remap_index], parameters)
+#define GET_WindowPos3fvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3fvMESA_remap_index])
+#define SET_WindowPos3fvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3fvMESA_remap_index], fn)
+#define CALL_WindowPos3iMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), driDispatchRemapTable[WindowPos3iMESA_remap_index], parameters)
+#define GET_WindowPos3iMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3iMESA_remap_index])
+#define SET_WindowPos3iMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3iMESA_remap_index], fn)
+#define CALL_WindowPos3ivMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[WindowPos3ivMESA_remap_index], parameters)
+#define GET_WindowPos3ivMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3ivMESA_remap_index])
+#define SET_WindowPos3ivMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3ivMESA_remap_index], fn)
+#define CALL_WindowPos3sMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), driDispatchRemapTable[WindowPos3sMESA_remap_index], parameters)
+#define GET_WindowPos3sMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3sMESA_remap_index])
+#define SET_WindowPos3sMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3sMESA_remap_index], fn)
+#define CALL_WindowPos3svMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[WindowPos3svMESA_remap_index], parameters)
+#define GET_WindowPos3svMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3svMESA_remap_index])
+#define SET_WindowPos3svMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3svMESA_remap_index], fn)
+#define CALL_WindowPos4dMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[WindowPos4dMESA_remap_index], parameters)
+#define GET_WindowPos4dMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4dMESA_remap_index])
+#define SET_WindowPos4dMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4dMESA_remap_index], fn)
+#define CALL_WindowPos4dvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[WindowPos4dvMESA_remap_index], parameters)
+#define GET_WindowPos4dvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4dvMESA_remap_index])
+#define SET_WindowPos4dvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4dvMESA_remap_index], fn)
+#define CALL_WindowPos4fMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[WindowPos4fMESA_remap_index], parameters)
+#define GET_WindowPos4fMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4fMESA_remap_index])
+#define SET_WindowPos4fMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4fMESA_remap_index], fn)
+#define CALL_WindowPos4fvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[WindowPos4fvMESA_remap_index], parameters)
+#define GET_WindowPos4fvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4fvMESA_remap_index])
+#define SET_WindowPos4fvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4fvMESA_remap_index], fn)
+#define CALL_WindowPos4iMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), driDispatchRemapTable[WindowPos4iMESA_remap_index], parameters)
+#define GET_WindowPos4iMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4iMESA_remap_index])
+#define SET_WindowPos4iMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4iMESA_remap_index], fn)
+#define CALL_WindowPos4ivMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[WindowPos4ivMESA_remap_index], parameters)
+#define GET_WindowPos4ivMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4ivMESA_remap_index])
+#define SET_WindowPos4ivMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4ivMESA_remap_index], fn)
+#define CALL_WindowPos4sMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), driDispatchRemapTable[WindowPos4sMESA_remap_index], parameters)
+#define GET_WindowPos4sMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4sMESA_remap_index])
+#define SET_WindowPos4sMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4sMESA_remap_index], fn)
+#define CALL_WindowPos4svMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[WindowPos4svMESA_remap_index], parameters)
+#define GET_WindowPos4svMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4svMESA_remap_index])
+#define SET_WindowPos4svMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4svMESA_remap_index], fn)
+#define CALL_BlendFuncSeparateEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[BlendFuncSeparateEXT_remap_index], parameters)
+#define GET_BlendFuncSeparateEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BlendFuncSeparateEXT_remap_index])
+#define SET_BlendFuncSeparateEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BlendFuncSeparateEXT_remap_index], fn)
+#define CALL_IndexMaterialEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[IndexMaterialEXT_remap_index], parameters)
+#define GET_IndexMaterialEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IndexMaterialEXT_remap_index])
+#define SET_IndexMaterialEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IndexMaterialEXT_remap_index], fn)
+#define CALL_IndexFuncEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLclampf)), driDispatchRemapTable[IndexFuncEXT_remap_index], parameters)
+#define GET_IndexFuncEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IndexFuncEXT_remap_index])
+#define SET_IndexFuncEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IndexFuncEXT_remap_index], fn)
+#define CALL_LockArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei)), driDispatchRemapTable[LockArraysEXT_remap_index], parameters)
+#define GET_LockArraysEXT(disp) GET_by_offset(disp, driDispatchRemapTable[LockArraysEXT_remap_index])
+#define SET_LockArraysEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LockArraysEXT_remap_index], fn)
+#define CALL_UnlockArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[UnlockArraysEXT_remap_index], parameters)
+#define GET_UnlockArraysEXT(disp) GET_by_offset(disp, driDispatchRemapTable[UnlockArraysEXT_remap_index])
+#define SET_UnlockArraysEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UnlockArraysEXT_remap_index], fn)
+#define CALL_CullParameterdvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble *)), driDispatchRemapTable[CullParameterdvEXT_remap_index], parameters)
+#define GET_CullParameterdvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[CullParameterdvEXT_remap_index])
+#define SET_CullParameterdvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CullParameterdvEXT_remap_index], fn)
+#define CALL_CullParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[CullParameterfvEXT_remap_index], parameters)
+#define GET_CullParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[CullParameterfvEXT_remap_index])
+#define SET_CullParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CullParameterfvEXT_remap_index], fn)
+#define CALL_HintPGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[HintPGI_remap_index], parameters)
+#define GET_HintPGI(disp) GET_by_offset(disp, driDispatchRemapTable[HintPGI_remap_index])
+#define SET_HintPGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[HintPGI_remap_index], fn)
+#define CALL_FogCoordfEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), driDispatchRemapTable[FogCoordfEXT_remap_index], parameters)
+#define GET_FogCoordfEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoordfEXT_remap_index])
+#define SET_FogCoordfEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoordfEXT_remap_index], fn)
+#define CALL_FogCoordfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[FogCoordfvEXT_remap_index], parameters)
+#define GET_FogCoordfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoordfvEXT_remap_index])
+#define SET_FogCoordfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoordfvEXT_remap_index], fn)
+#define CALL_FogCoorddEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), driDispatchRemapTable[FogCoorddEXT_remap_index], parameters)
+#define GET_FogCoorddEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoorddEXT_remap_index])
+#define SET_FogCoorddEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoorddEXT_remap_index], fn)
+#define CALL_FogCoorddvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[FogCoorddvEXT_remap_index], parameters)
+#define GET_FogCoorddvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoorddvEXT_remap_index])
+#define SET_FogCoorddvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoorddvEXT_remap_index], fn)
+#define CALL_FogCoordPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[FogCoordPointerEXT_remap_index], parameters)
+#define GET_FogCoordPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoordPointerEXT_remap_index])
+#define SET_FogCoordPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoordPointerEXT_remap_index], fn)
+#define CALL_GetColorTableEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetColorTableEXT_remap_index], parameters)
+#define GET_GetColorTableEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableEXT_remap_index])
+#define SET_GetColorTableEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableEXT_remap_index], fn)
+#define CALL_GetColorTableParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetColorTableParameterivEXT_remap_index], parameters)
+#define GET_GetColorTableParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivEXT_remap_index])
+#define SET_GetColorTableParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivEXT_remap_index], fn)
+#define CALL_GetColorTableParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetColorTableParameterfvEXT_remap_index], parameters)
+#define GET_GetColorTableParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvEXT_remap_index])
+#define SET_GetColorTableParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvEXT_remap_index], fn)
+#define CALL_TbufferMask3DFX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[TbufferMask3DFX_remap_index], parameters)
+#define GET_TbufferMask3DFX(disp) GET_by_offset(disp, driDispatchRemapTable[TbufferMask3DFX_remap_index])
+#define SET_TbufferMask3DFX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TbufferMask3DFX_remap_index], fn)
+#define CALL_CompressedTexImage3DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexImage3DARB_remap_index], parameters)
+#define GET_CompressedTexImage3DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexImage3DARB_remap_index])
+#define SET_CompressedTexImage3DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexImage3DARB_remap_index], fn)
+#define CALL_CompressedTexImage2DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexImage2DARB_remap_index], parameters)
+#define GET_CompressedTexImage2DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexImage2DARB_remap_index])
+#define SET_CompressedTexImage2DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexImage2DARB_remap_index], fn)
+#define CALL_CompressedTexImage1DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexImage1DARB_remap_index], parameters)
+#define GET_CompressedTexImage1DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexImage1DARB_remap_index])
+#define SET_CompressedTexImage1DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexImage1DARB_remap_index], fn)
+#define CALL_CompressedTexSubImage3DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexSubImage3DARB_remap_index], parameters)
+#define GET_CompressedTexSubImage3DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage3DARB_remap_index])
+#define SET_CompressedTexSubImage3DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage3DARB_remap_index], fn)
+#define CALL_CompressedTexSubImage2DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexSubImage2DARB_remap_index], parameters)
+#define GET_CompressedTexSubImage2DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage2DARB_remap_index])
+#define SET_CompressedTexSubImage2DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage2DARB_remap_index], fn)
+#define CALL_CompressedTexSubImage1DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexSubImage1DARB_remap_index], parameters)
+#define GET_CompressedTexSubImage1DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage1DARB_remap_index])
+#define SET_CompressedTexSubImage1DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage1DARB_remap_index], fn)
+#define CALL_GetCompressedTexImageARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLvoid *)), driDispatchRemapTable[GetCompressedTexImageARB_remap_index], parameters)
+#define GET_GetCompressedTexImageARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetCompressedTexImageARB_remap_index])
+#define SET_GetCompressedTexImageARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCompressedTexImageARB_remap_index], fn)
+#define CALL_SecondaryColor3bEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte)), driDispatchRemapTable[SecondaryColor3bEXT_remap_index], parameters)
+#define GET_SecondaryColor3bEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bEXT_remap_index])
+#define SET_SecondaryColor3bEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bEXT_remap_index], fn)
+#define CALL_SecondaryColor3bvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), driDispatchRemapTable[SecondaryColor3bvEXT_remap_index], parameters)
+#define GET_SecondaryColor3bvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bvEXT_remap_index])
+#define SET_SecondaryColor3bvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bvEXT_remap_index], fn)
+#define CALL_SecondaryColor3dEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[SecondaryColor3dEXT_remap_index], parameters)
+#define GET_SecondaryColor3dEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dEXT_remap_index])
+#define SET_SecondaryColor3dEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dEXT_remap_index], fn)
+#define CALL_SecondaryColor3dvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[SecondaryColor3dvEXT_remap_index], parameters)
+#define GET_SecondaryColor3dvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dvEXT_remap_index])
+#define SET_SecondaryColor3dvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dvEXT_remap_index], fn)
+#define CALL_SecondaryColor3fEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[SecondaryColor3fEXT_remap_index], parameters)
+#define GET_SecondaryColor3fEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fEXT_remap_index])
+#define SET_SecondaryColor3fEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fEXT_remap_index], fn)
+#define CALL_SecondaryColor3fvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[SecondaryColor3fvEXT_remap_index], parameters)
+#define GET_SecondaryColor3fvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fvEXT_remap_index])
+#define SET_SecondaryColor3fvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fvEXT_remap_index], fn)
+#define CALL_SecondaryColor3iEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), driDispatchRemapTable[SecondaryColor3iEXT_remap_index], parameters)
+#define GET_SecondaryColor3iEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3iEXT_remap_index])
+#define SET_SecondaryColor3iEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3iEXT_remap_index], fn)
+#define CALL_SecondaryColor3ivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[SecondaryColor3ivEXT_remap_index], parameters)
+#define GET_SecondaryColor3ivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ivEXT_remap_index])
+#define SET_SecondaryColor3ivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ivEXT_remap_index], fn)
+#define CALL_SecondaryColor3sEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), driDispatchRemapTable[SecondaryColor3sEXT_remap_index], parameters)
+#define GET_SecondaryColor3sEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3sEXT_remap_index])
+#define SET_SecondaryColor3sEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3sEXT_remap_index], fn)
+#define CALL_SecondaryColor3svEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[SecondaryColor3svEXT_remap_index], parameters)
+#define GET_SecondaryColor3svEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3svEXT_remap_index])
+#define SET_SecondaryColor3svEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3svEXT_remap_index], fn)
+#define CALL_SecondaryColor3ubEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte, GLubyte, GLubyte)), driDispatchRemapTable[SecondaryColor3ubEXT_remap_index], parameters)
+#define GET_SecondaryColor3ubEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubEXT_remap_index])
+#define SET_SecondaryColor3ubEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubEXT_remap_index], fn)
+#define CALL_SecondaryColor3ubvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), driDispatchRemapTable[SecondaryColor3ubvEXT_remap_index], parameters)
+#define GET_SecondaryColor3ubvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubvEXT_remap_index])
+#define SET_SecondaryColor3ubvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubvEXT_remap_index], fn)
+#define CALL_SecondaryColor3uiEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLuint)), driDispatchRemapTable[SecondaryColor3uiEXT_remap_index], parameters)
+#define GET_SecondaryColor3uiEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uiEXT_remap_index])
+#define SET_SecondaryColor3uiEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uiEXT_remap_index], fn)
+#define CALL_SecondaryColor3uivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLuint *)), driDispatchRemapTable[SecondaryColor3uivEXT_remap_index], parameters)
+#define GET_SecondaryColor3uivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uivEXT_remap_index])
+#define SET_SecondaryColor3uivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uivEXT_remap_index], fn)
+#define CALL_SecondaryColor3usEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLushort, GLushort, GLushort)), driDispatchRemapTable[SecondaryColor3usEXT_remap_index], parameters)
+#define GET_SecondaryColor3usEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usEXT_remap_index])
+#define SET_SecondaryColor3usEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usEXT_remap_index], fn)
+#define CALL_SecondaryColor3usvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLushort *)), driDispatchRemapTable[SecondaryColor3usvEXT_remap_index], parameters)
+#define GET_SecondaryColor3usvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usvEXT_remap_index])
+#define SET_SecondaryColor3usvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usvEXT_remap_index], fn)
+#define CALL_SecondaryColorPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[SecondaryColorPointerEXT_remap_index], parameters)
+#define GET_SecondaryColorPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColorPointerEXT_remap_index])
+#define SET_SecondaryColorPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColorPointerEXT_remap_index], fn)
+#define CALL_AreProgramsResidentNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLsizei, const GLuint *, GLboolean *)), driDispatchRemapTable[AreProgramsResidentNV_remap_index], parameters)
+#define GET_AreProgramsResidentNV(disp) GET_by_offset(disp, driDispatchRemapTable[AreProgramsResidentNV_remap_index])
+#define SET_AreProgramsResidentNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AreProgramsResidentNV_remap_index], fn)
+#define CALL_BindProgramNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindProgramNV_remap_index], parameters)
+#define GET_BindProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[BindProgramNV_remap_index])
+#define SET_BindProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindProgramNV_remap_index], fn)
+#define CALL_DeleteProgramsNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteProgramsNV_remap_index], parameters)
+#define GET_DeleteProgramsNV(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteProgramsNV_remap_index])
+#define SET_DeleteProgramsNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteProgramsNV_remap_index], fn)
+#define CALL_ExecuteProgramNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ExecuteProgramNV_remap_index], parameters)
+#define GET_ExecuteProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[ExecuteProgramNV_remap_index])
+#define SET_ExecuteProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ExecuteProgramNV_remap_index], fn)
+#define CALL_GenProgramsNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenProgramsNV_remap_index], parameters)
+#define GET_GenProgramsNV(disp) GET_by_offset(disp, driDispatchRemapTable[GenProgramsNV_remap_index])
+#define SET_GenProgramsNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenProgramsNV_remap_index], fn)
+#define CALL_GetProgramParameterdvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLdouble *)), driDispatchRemapTable[GetProgramParameterdvNV_remap_index], parameters)
+#define GET_GetProgramParameterdvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramParameterdvNV_remap_index])
+#define SET_GetProgramParameterdvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramParameterdvNV_remap_index], fn)
+#define CALL_GetProgramParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetProgramParameterfvNV_remap_index], parameters)
+#define GET_GetProgramParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramParameterfvNV_remap_index])
+#define SET_GetProgramParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramParameterfvNV_remap_index], fn)
+#define CALL_GetProgramivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetProgramivNV_remap_index], parameters)
+#define GET_GetProgramivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramivNV_remap_index])
+#define SET_GetProgramivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramivNV_remap_index], fn)
+#define CALL_GetProgramStringNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLubyte *)), driDispatchRemapTable[GetProgramStringNV_remap_index], parameters)
+#define GET_GetProgramStringNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramStringNV_remap_index])
+#define SET_GetProgramStringNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramStringNV_remap_index], fn)
+#define CALL_GetTrackMatrixivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLint *)), driDispatchRemapTable[GetTrackMatrixivNV_remap_index], parameters)
+#define GET_GetTrackMatrixivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetTrackMatrixivNV_remap_index])
+#define SET_GetTrackMatrixivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetTrackMatrixivNV_remap_index], fn)
+#define CALL_GetVertexAttribdvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLdouble *)), driDispatchRemapTable[GetVertexAttribdvARB_remap_index], parameters)
+#define GET_GetVertexAttribdvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvARB_remap_index])
+#define SET_GetVertexAttribdvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvARB_remap_index], fn)
+#define CALL_GetVertexAttribfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetVertexAttribfvARB_remap_index], parameters)
+#define GET_GetVertexAttribfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvARB_remap_index])
+#define SET_GetVertexAttribfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvARB_remap_index], fn)
+#define CALL_GetVertexAttribivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetVertexAttribivARB_remap_index], parameters)
+#define GET_GetVertexAttribivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivARB_remap_index])
+#define SET_GetVertexAttribivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivARB_remap_index], fn)
+#define CALL_GetVertexAttribPointervNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLvoid **)), driDispatchRemapTable[GetVertexAttribPointervNV_remap_index], parameters)
+#define GET_GetVertexAttribPointervNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribPointervNV_remap_index])
+#define SET_GetVertexAttribPointervNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribPointervNV_remap_index], fn)
+#define CALL_IsProgramNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsProgramNV_remap_index], parameters)
+#define GET_IsProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[IsProgramNV_remap_index])
+#define SET_IsProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsProgramNV_remap_index], fn)
+#define CALL_LoadProgramNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLsizei, const GLubyte *)), driDispatchRemapTable[LoadProgramNV_remap_index], parameters)
+#define GET_LoadProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[LoadProgramNV_remap_index])
+#define SET_LoadProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadProgramNV_remap_index], fn)
+#define CALL_ProgramParameter4dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramParameter4dNV_remap_index], parameters)
+#define GET_ProgramParameter4dNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dNV_remap_index])
+#define SET_ProgramParameter4dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dNV_remap_index], fn)
+#define CALL_ProgramParameter4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramParameter4dvNV_remap_index], parameters)
+#define GET_ProgramParameter4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dvNV_remap_index])
+#define SET_ProgramParameter4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dvNV_remap_index], fn)
+#define CALL_ProgramParameter4fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramParameter4fNV_remap_index], parameters)
+#define GET_ProgramParameter4fNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fNV_remap_index])
+#define SET_ProgramParameter4fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fNV_remap_index], fn)
+#define CALL_ProgramParameter4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramParameter4fvNV_remap_index], parameters)
+#define GET_ProgramParameter4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fvNV_remap_index])
+#define SET_ProgramParameter4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fvNV_remap_index], fn)
+#define CALL_ProgramParameters4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramParameters4dvNV_remap_index], parameters)
+#define GET_ProgramParameters4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameters4dvNV_remap_index])
+#define SET_ProgramParameters4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameters4dvNV_remap_index], fn)
+#define CALL_ProgramParameters4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramParameters4fvNV_remap_index], parameters)
+#define GET_ProgramParameters4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameters4fvNV_remap_index])
+#define SET_ProgramParameters4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameters4fvNV_remap_index], fn)
+#define CALL_RequestResidentProgramsNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[RequestResidentProgramsNV_remap_index], parameters)
+#define GET_RequestResidentProgramsNV(disp) GET_by_offset(disp, driDispatchRemapTable[RequestResidentProgramsNV_remap_index])
+#define SET_RequestResidentProgramsNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[RequestResidentProgramsNV_remap_index], fn)
+#define CALL_TrackMatrixNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLenum)), driDispatchRemapTable[TrackMatrixNV_remap_index], parameters)
+#define GET_TrackMatrixNV(disp) GET_by_offset(disp, driDispatchRemapTable[TrackMatrixNV_remap_index])
+#define SET_TrackMatrixNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TrackMatrixNV_remap_index], fn)
+#define CALL_VertexAttribPointerNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexAttribPointerNV_remap_index], parameters)
+#define GET_VertexAttribPointerNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerNV_remap_index])
+#define SET_VertexAttribPointerNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerNV_remap_index], fn)
+#define CALL_VertexAttrib1dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble)), driDispatchRemapTable[VertexAttrib1dARB_remap_index], parameters)
+#define GET_VertexAttrib1dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dARB_remap_index])
+#define SET_VertexAttrib1dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dARB_remap_index], fn)
+#define CALL_VertexAttrib1dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib1dvARB_remap_index], parameters)
+#define GET_VertexAttrib1dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvARB_remap_index])
+#define SET_VertexAttrib1dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvARB_remap_index], fn)
+#define CALL_VertexAttrib1fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat)), driDispatchRemapTable[VertexAttrib1fARB_remap_index], parameters)
+#define GET_VertexAttrib1fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fARB_remap_index])
+#define SET_VertexAttrib1fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fARB_remap_index], fn)
+#define CALL_VertexAttrib1fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib1fvARB_remap_index], parameters)
+#define GET_VertexAttrib1fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvARB_remap_index])
+#define SET_VertexAttrib1fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvARB_remap_index], fn)
+#define CALL_VertexAttrib1sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort)), driDispatchRemapTable[VertexAttrib1sARB_remap_index], parameters)
+#define GET_VertexAttrib1sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sARB_remap_index])
+#define SET_VertexAttrib1sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sARB_remap_index], fn)
+#define CALL_VertexAttrib1svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib1svARB_remap_index], parameters)
+#define GET_VertexAttrib1svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svARB_remap_index])
+#define SET_VertexAttrib1svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svARB_remap_index], fn)
+#define CALL_VertexAttrib2dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib2dARB_remap_index], parameters)
+#define GET_VertexAttrib2dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dARB_remap_index])
+#define SET_VertexAttrib2dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dARB_remap_index], fn)
+#define CALL_VertexAttrib2dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib2dvARB_remap_index], parameters)
+#define GET_VertexAttrib2dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvARB_remap_index])
+#define SET_VertexAttrib2dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvARB_remap_index], fn)
+#define CALL_VertexAttrib2fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib2fARB_remap_index], parameters)
+#define GET_VertexAttrib2fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fARB_remap_index])
+#define SET_VertexAttrib2fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fARB_remap_index], fn)
+#define CALL_VertexAttrib2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib2fvARB_remap_index], parameters)
+#define GET_VertexAttrib2fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvARB_remap_index])
+#define SET_VertexAttrib2fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvARB_remap_index], fn)
+#define CALL_VertexAttrib2sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib2sARB_remap_index], parameters)
+#define GET_VertexAttrib2sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sARB_remap_index])
+#define SET_VertexAttrib2sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sARB_remap_index], fn)
+#define CALL_VertexAttrib2svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib2svARB_remap_index], parameters)
+#define GET_VertexAttrib2svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svARB_remap_index])
+#define SET_VertexAttrib2svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svARB_remap_index], fn)
+#define CALL_VertexAttrib3dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib3dARB_remap_index], parameters)
+#define GET_VertexAttrib3dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dARB_remap_index])
+#define SET_VertexAttrib3dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dARB_remap_index], fn)
+#define CALL_VertexAttrib3dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib3dvARB_remap_index], parameters)
+#define GET_VertexAttrib3dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvARB_remap_index])
+#define SET_VertexAttrib3dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvARB_remap_index], fn)
+#define CALL_VertexAttrib3fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib3fARB_remap_index], parameters)
+#define GET_VertexAttrib3fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fARB_remap_index])
+#define SET_VertexAttrib3fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fARB_remap_index], fn)
+#define CALL_VertexAttrib3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib3fvARB_remap_index], parameters)
+#define GET_VertexAttrib3fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvARB_remap_index])
+#define SET_VertexAttrib3fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvARB_remap_index], fn)
+#define CALL_VertexAttrib3sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib3sARB_remap_index], parameters)
+#define GET_VertexAttrib3sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sARB_remap_index])
+#define SET_VertexAttrib3sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sARB_remap_index], fn)
+#define CALL_VertexAttrib3svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib3svARB_remap_index], parameters)
+#define GET_VertexAttrib3svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svARB_remap_index])
+#define SET_VertexAttrib3svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svARB_remap_index], fn)
+#define CALL_VertexAttrib4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib4dARB_remap_index], parameters)
+#define GET_VertexAttrib4dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dARB_remap_index])
+#define SET_VertexAttrib4dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dARB_remap_index], fn)
+#define CALL_VertexAttrib4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib4dvARB_remap_index], parameters)
+#define GET_VertexAttrib4dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvARB_remap_index])
+#define SET_VertexAttrib4dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvARB_remap_index], fn)
+#define CALL_VertexAttrib4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib4fARB_remap_index], parameters)
+#define GET_VertexAttrib4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fARB_remap_index])
+#define SET_VertexAttrib4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fARB_remap_index], fn)
+#define CALL_VertexAttrib4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib4fvARB_remap_index], parameters)
+#define GET_VertexAttrib4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvARB_remap_index])
+#define SET_VertexAttrib4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvARB_remap_index], fn)
+#define CALL_VertexAttrib4sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib4sARB_remap_index], parameters)
+#define GET_VertexAttrib4sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sARB_remap_index])
+#define SET_VertexAttrib4sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sARB_remap_index], fn)
+#define CALL_VertexAttrib4svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib4svARB_remap_index], parameters)
+#define GET_VertexAttrib4svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svARB_remap_index])
+#define SET_VertexAttrib4svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svARB_remap_index], fn)
+#define CALL_VertexAttrib4NubARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte)), driDispatchRemapTable[VertexAttrib4NubARB_remap_index], parameters)
+#define GET_VertexAttrib4NubARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubARB_remap_index])
+#define SET_VertexAttrib4NubARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubARB_remap_index], fn)
+#define CALL_VertexAttrib4NubvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLubyte *)), driDispatchRemapTable[VertexAttrib4NubvARB_remap_index], parameters)
+#define GET_VertexAttrib4NubvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubvARB_remap_index])
+#define SET_VertexAttrib4NubvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubvARB_remap_index], fn)
+#define CALL_VertexAttribs1dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs1dvNV_remap_index], parameters)
+#define GET_VertexAttribs1dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs1dvNV_remap_index])
+#define SET_VertexAttribs1dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs1dvNV_remap_index], fn)
+#define CALL_VertexAttribs1fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs1fvNV_remap_index], parameters)
+#define GET_VertexAttribs1fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs1fvNV_remap_index])
+#define SET_VertexAttribs1fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs1fvNV_remap_index], fn)
+#define CALL_VertexAttribs1svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs1svNV_remap_index], parameters)
+#define GET_VertexAttribs1svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs1svNV_remap_index])
+#define SET_VertexAttribs1svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs1svNV_remap_index], fn)
+#define CALL_VertexAttribs2dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs2dvNV_remap_index], parameters)
+#define GET_VertexAttribs2dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs2dvNV_remap_index])
+#define SET_VertexAttribs2dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs2dvNV_remap_index], fn)
+#define CALL_VertexAttribs2fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs2fvNV_remap_index], parameters)
+#define GET_VertexAttribs2fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs2fvNV_remap_index])
+#define SET_VertexAttribs2fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs2fvNV_remap_index], fn)
+#define CALL_VertexAttribs2svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs2svNV_remap_index], parameters)
+#define GET_VertexAttribs2svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs2svNV_remap_index])
+#define SET_VertexAttribs2svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs2svNV_remap_index], fn)
+#define CALL_VertexAttribs3dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs3dvNV_remap_index], parameters)
+#define GET_VertexAttribs3dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs3dvNV_remap_index])
+#define SET_VertexAttribs3dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs3dvNV_remap_index], fn)
+#define CALL_VertexAttribs3fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs3fvNV_remap_index], parameters)
+#define GET_VertexAttribs3fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs3fvNV_remap_index])
+#define SET_VertexAttribs3fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs3fvNV_remap_index], fn)
+#define CALL_VertexAttribs3svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs3svNV_remap_index], parameters)
+#define GET_VertexAttribs3svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs3svNV_remap_index])
+#define SET_VertexAttribs3svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs3svNV_remap_index], fn)
+#define CALL_VertexAttribs4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs4dvNV_remap_index], parameters)
+#define GET_VertexAttribs4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4dvNV_remap_index])
+#define SET_VertexAttribs4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4dvNV_remap_index], fn)
+#define CALL_VertexAttribs4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs4fvNV_remap_index], parameters)
+#define GET_VertexAttribs4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4fvNV_remap_index])
+#define SET_VertexAttribs4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4fvNV_remap_index], fn)
+#define CALL_VertexAttribs4svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs4svNV_remap_index], parameters)
+#define GET_VertexAttribs4svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4svNV_remap_index])
+#define SET_VertexAttribs4svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4svNV_remap_index], fn)
+#define CALL_VertexAttribs4ubvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *)), driDispatchRemapTable[VertexAttribs4ubvNV_remap_index], parameters)
+#define GET_VertexAttribs4ubvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4ubvNV_remap_index])
+#define SET_VertexAttribs4ubvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4ubvNV_remap_index], fn)
+#define CALL_PointParameteriNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[PointParameteriNV_remap_index], parameters)
+#define GET_PointParameteriNV(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameteriNV_remap_index])
+#define SET_PointParameteriNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameteriNV_remap_index], fn)
+#define CALL_PointParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[PointParameterivNV_remap_index], parameters)
+#define GET_PointParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameterivNV_remap_index])
+#define SET_PointParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameterivNV_remap_index], fn)
+#define CALL_MultiDrawArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint *, GLsizei *, GLsizei)), driDispatchRemapTable[MultiDrawArraysEXT_remap_index], parameters)
+#define GET_MultiDrawArraysEXT(disp) GET_by_offset(disp, driDispatchRemapTable[MultiDrawArraysEXT_remap_index])
+#define SET_MultiDrawArraysEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiDrawArraysEXT_remap_index], fn)
+#define CALL_MultiDrawElementsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei)), driDispatchRemapTable[MultiDrawElementsEXT_remap_index], parameters)
+#define GET_MultiDrawElementsEXT(disp) GET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsEXT_remap_index])
+#define SET_MultiDrawElementsEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsEXT_remap_index], fn)
+#define CALL_ActiveStencilFaceEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[ActiveStencilFaceEXT_remap_index], parameters)
+#define GET_ActiveStencilFaceEXT(disp) GET_by_offset(disp, driDispatchRemapTable[ActiveStencilFaceEXT_remap_index])
+#define SET_ActiveStencilFaceEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ActiveStencilFaceEXT_remap_index], fn)
+#define CALL_DeleteFencesNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteFencesNV_remap_index], parameters)
+#define GET_DeleteFencesNV(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteFencesNV_remap_index])
+#define SET_DeleteFencesNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteFencesNV_remap_index], fn)
+#define CALL_GenFencesNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenFencesNV_remap_index], parameters)
+#define GET_GenFencesNV(disp) GET_by_offset(disp, driDispatchRemapTable[GenFencesNV_remap_index])
+#define SET_GenFencesNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenFencesNV_remap_index], fn)
+#define CALL_IsFenceNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsFenceNV_remap_index], parameters)
+#define GET_IsFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[IsFenceNV_remap_index])
+#define SET_IsFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsFenceNV_remap_index], fn)
+#define CALL_TestFenceNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[TestFenceNV_remap_index], parameters)
+#define GET_TestFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[TestFenceNV_remap_index])
+#define SET_TestFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TestFenceNV_remap_index], fn)
+#define CALL_GetFenceivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetFenceivNV_remap_index], parameters)
+#define GET_GetFenceivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetFenceivNV_remap_index])
+#define SET_GetFenceivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFenceivNV_remap_index], fn)
+#define CALL_FinishFenceNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[FinishFenceNV_remap_index], parameters)
+#define GET_FinishFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[FinishFenceNV_remap_index])
+#define SET_FinishFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FinishFenceNV_remap_index], fn)
+#define CALL_SetFenceNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum)), driDispatchRemapTable[SetFenceNV_remap_index], parameters)
+#define GET_SetFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[SetFenceNV_remap_index])
+#define SET_SetFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SetFenceNV_remap_index], fn)
+#define CALL_VertexAttrib4bvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLbyte *)), driDispatchRemapTable[VertexAttrib4bvARB_remap_index], parameters)
+#define GET_VertexAttrib4bvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4bvARB_remap_index])
+#define SET_VertexAttrib4bvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4bvARB_remap_index], fn)
+#define CALL_VertexAttrib4ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLint *)), driDispatchRemapTable[VertexAttrib4ivARB_remap_index], parameters)
+#define GET_VertexAttrib4ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ivARB_remap_index])
+#define SET_VertexAttrib4ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ivARB_remap_index], fn)
+#define CALL_VertexAttrib4ubvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLubyte *)), driDispatchRemapTable[VertexAttrib4ubvARB_remap_index], parameters)
+#define GET_VertexAttrib4ubvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvARB_remap_index])
+#define SET_VertexAttrib4ubvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvARB_remap_index], fn)
+#define CALL_VertexAttrib4usvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLushort *)), driDispatchRemapTable[VertexAttrib4usvARB_remap_index], parameters)
+#define GET_VertexAttrib4usvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4usvARB_remap_index])
+#define SET_VertexAttrib4usvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4usvARB_remap_index], fn)
+#define CALL_VertexAttrib4uivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLuint *)), driDispatchRemapTable[VertexAttrib4uivARB_remap_index], parameters)
+#define GET_VertexAttrib4uivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4uivARB_remap_index])
+#define SET_VertexAttrib4uivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4uivARB_remap_index], fn)
+#define CALL_VertexAttrib4NbvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLbyte *)), driDispatchRemapTable[VertexAttrib4NbvARB_remap_index], parameters)
+#define GET_VertexAttrib4NbvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NbvARB_remap_index])
+#define SET_VertexAttrib4NbvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NbvARB_remap_index], fn)
+#define CALL_VertexAttrib4NsvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib4NsvARB_remap_index], parameters)
+#define GET_VertexAttrib4NsvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NsvARB_remap_index])
+#define SET_VertexAttrib4NsvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NsvARB_remap_index], fn)
+#define CALL_VertexAttrib4NivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLint *)), driDispatchRemapTable[VertexAttrib4NivARB_remap_index], parameters)
+#define GET_VertexAttrib4NivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NivARB_remap_index])
+#define SET_VertexAttrib4NivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NivARB_remap_index], fn)
+#define CALL_VertexAttrib4NusvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLushort *)), driDispatchRemapTable[VertexAttrib4NusvARB_remap_index], parameters)
+#define GET_VertexAttrib4NusvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NusvARB_remap_index])
+#define SET_VertexAttrib4NusvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NusvARB_remap_index], fn)
+#define CALL_VertexAttrib4NuivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLuint *)), driDispatchRemapTable[VertexAttrib4NuivARB_remap_index], parameters)
+#define GET_VertexAttrib4NuivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NuivARB_remap_index])
+#define SET_VertexAttrib4NuivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NuivARB_remap_index], fn)
+#define CALL_VertexAttribPointerARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexAttribPointerARB_remap_index], parameters)
+#define GET_VertexAttribPointerARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerARB_remap_index])
+#define SET_VertexAttribPointerARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerARB_remap_index], fn)
+#define CALL_EnableVertexAttribArrayARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[EnableVertexAttribArrayARB_remap_index], parameters)
+#define GET_EnableVertexAttribArrayARB(disp) GET_by_offset(disp, driDispatchRemapTable[EnableVertexAttribArrayARB_remap_index])
+#define SET_EnableVertexAttribArrayARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EnableVertexAttribArrayARB_remap_index], fn)
+#define CALL_DisableVertexAttribArrayARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[DisableVertexAttribArrayARB_remap_index], parameters)
+#define GET_DisableVertexAttribArrayARB(disp) GET_by_offset(disp, driDispatchRemapTable[DisableVertexAttribArrayARB_remap_index])
+#define SET_DisableVertexAttribArrayARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DisableVertexAttribArrayARB_remap_index], fn)
+#define CALL_ProgramStringARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[ProgramStringARB_remap_index], parameters)
+#define GET_ProgramStringARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramStringARB_remap_index])
+#define SET_ProgramStringARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramStringARB_remap_index], fn)
+#define CALL_ProgramEnvParameter4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramEnvParameter4dARB_remap_index], parameters)
+#define GET_ProgramEnvParameter4dARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dARB_remap_index])
+#define SET_ProgramEnvParameter4dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dARB_remap_index], fn)
+#define CALL_ProgramEnvParameter4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramEnvParameter4dvARB_remap_index], parameters)
+#define GET_ProgramEnvParameter4dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dvARB_remap_index])
+#define SET_ProgramEnvParameter4dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dvARB_remap_index], fn)
+#define CALL_ProgramEnvParameter4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramEnvParameter4fARB_remap_index], parameters)
+#define GET_ProgramEnvParameter4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fARB_remap_index])
+#define SET_ProgramEnvParameter4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fARB_remap_index], fn)
+#define CALL_ProgramEnvParameter4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramEnvParameter4fvARB_remap_index], parameters)
+#define GET_ProgramEnvParameter4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fvARB_remap_index])
+#define SET_ProgramEnvParameter4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fvARB_remap_index], fn)
+#define CALL_ProgramLocalParameter4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramLocalParameter4dARB_remap_index], parameters)
+#define GET_ProgramLocalParameter4dARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dARB_remap_index])
+#define SET_ProgramLocalParameter4dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dARB_remap_index], fn)
+#define CALL_ProgramLocalParameter4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramLocalParameter4dvARB_remap_index], parameters)
+#define GET_ProgramLocalParameter4dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dvARB_remap_index])
+#define SET_ProgramLocalParameter4dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dvARB_remap_index], fn)
+#define CALL_ProgramLocalParameter4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramLocalParameter4fARB_remap_index], parameters)
+#define GET_ProgramLocalParameter4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fARB_remap_index])
+#define SET_ProgramLocalParameter4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fARB_remap_index], fn)
+#define CALL_ProgramLocalParameter4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramLocalParameter4fvARB_remap_index], parameters)
+#define GET_ProgramLocalParameter4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fvARB_remap_index])
+#define SET_ProgramLocalParameter4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fvARB_remap_index], fn)
+#define CALL_GetProgramEnvParameterdvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble *)), driDispatchRemapTable[GetProgramEnvParameterdvARB_remap_index], parameters)
+#define GET_GetProgramEnvParameterdvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterdvARB_remap_index])
+#define SET_GetProgramEnvParameterdvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterdvARB_remap_index], fn)
+#define CALL_GetProgramEnvParameterfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat *)), driDispatchRemapTable[GetProgramEnvParameterfvARB_remap_index], parameters)
+#define GET_GetProgramEnvParameterfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterfvARB_remap_index])
+#define SET_GetProgramEnvParameterfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterfvARB_remap_index], fn)
+#define CALL_GetProgramLocalParameterdvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble *)), driDispatchRemapTable[GetProgramLocalParameterdvARB_remap_index], parameters)
+#define GET_GetProgramLocalParameterdvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterdvARB_remap_index])
+#define SET_GetProgramLocalParameterdvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterdvARB_remap_index], fn)
+#define CALL_GetProgramLocalParameterfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat *)), driDispatchRemapTable[GetProgramLocalParameterfvARB_remap_index], parameters)
+#define GET_GetProgramLocalParameterfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterfvARB_remap_index])
+#define SET_GetProgramLocalParameterfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterfvARB_remap_index], fn)
+#define CALL_GetProgramivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetProgramivARB_remap_index], parameters)
+#define GET_GetProgramivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramivARB_remap_index])
+#define SET_GetProgramivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramivARB_remap_index], fn)
+#define CALL_GetProgramStringARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetProgramStringARB_remap_index], parameters)
+#define GET_GetProgramStringARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramStringARB_remap_index])
+#define SET_GetProgramStringARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramStringARB_remap_index], fn)
+#define CALL_ProgramNamedParameter4fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramNamedParameter4fNV_remap_index], parameters)
+#define GET_ProgramNamedParameter4fNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fNV_remap_index])
+#define SET_ProgramNamedParameter4fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fNV_remap_index], fn)
+#define CALL_ProgramNamedParameter4dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramNamedParameter4dNV_remap_index], parameters)
+#define GET_ProgramNamedParameter4dNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dNV_remap_index])
+#define SET_ProgramNamedParameter4dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dNV_remap_index], fn)
+#define CALL_ProgramNamedParameter4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, const GLfloat *)), driDispatchRemapTable[ProgramNamedParameter4fvNV_remap_index], parameters)
+#define GET_ProgramNamedParameter4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fvNV_remap_index])
+#define SET_ProgramNamedParameter4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fvNV_remap_index], fn)
+#define CALL_ProgramNamedParameter4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, const GLdouble *)), driDispatchRemapTable[ProgramNamedParameter4dvNV_remap_index], parameters)
+#define GET_ProgramNamedParameter4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dvNV_remap_index])
+#define SET_ProgramNamedParameter4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dvNV_remap_index], fn)
+#define CALL_GetProgramNamedParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLfloat *)), driDispatchRemapTable[GetProgramNamedParameterfvNV_remap_index], parameters)
+#define GET_GetProgramNamedParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterfvNV_remap_index])
+#define SET_GetProgramNamedParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterfvNV_remap_index], fn)
+#define CALL_GetProgramNamedParameterdvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLdouble *)), driDispatchRemapTable[GetProgramNamedParameterdvNV_remap_index], parameters)
+#define GET_GetProgramNamedParameterdvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterdvNV_remap_index])
+#define SET_GetProgramNamedParameterdvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterdvNV_remap_index], fn)
+#define CALL_BindBufferARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindBufferARB_remap_index], parameters)
+#define GET_BindBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[BindBufferARB_remap_index])
+#define SET_BindBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindBufferARB_remap_index], fn)
+#define CALL_BufferDataARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizeiptrARB, const GLvoid *, GLenum)), driDispatchRemapTable[BufferDataARB_remap_index], parameters)
+#define GET_BufferDataARB(disp) GET_by_offset(disp, driDispatchRemapTable[BufferDataARB_remap_index])
+#define SET_BufferDataARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BufferDataARB_remap_index], fn)
+#define CALL_BufferSubDataARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid *)), driDispatchRemapTable[BufferSubDataARB_remap_index], parameters)
+#define GET_BufferSubDataARB(disp) GET_by_offset(disp, driDispatchRemapTable[BufferSubDataARB_remap_index])
+#define SET_BufferSubDataARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BufferSubDataARB_remap_index], fn)
+#define CALL_DeleteBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteBuffersARB_remap_index], parameters)
+#define GET_DeleteBuffersARB(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteBuffersARB_remap_index])
+#define SET_DeleteBuffersARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteBuffersARB_remap_index], fn)
+#define CALL_GenBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenBuffersARB_remap_index], parameters)
+#define GET_GenBuffersARB(disp) GET_by_offset(disp, driDispatchRemapTable[GenBuffersARB_remap_index])
+#define SET_GenBuffersARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenBuffersARB_remap_index], fn)
+#define CALL_GetBufferParameterivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetBufferParameterivARB_remap_index], parameters)
+#define GET_GetBufferParameterivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetBufferParameterivARB_remap_index])
+#define SET_GetBufferParameterivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetBufferParameterivARB_remap_index], fn)
+#define CALL_GetBufferPointervARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLvoid **)), driDispatchRemapTable[GetBufferPointervARB_remap_index], parameters)
+#define GET_GetBufferPointervARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetBufferPointervARB_remap_index])
+#define SET_GetBufferPointervARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetBufferPointervARB_remap_index], fn)
+#define CALL_GetBufferSubDataARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLintptrARB, GLsizeiptrARB, GLvoid *)), driDispatchRemapTable[GetBufferSubDataARB_remap_index], parameters)
+#define GET_GetBufferSubDataARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetBufferSubDataARB_remap_index])
+#define SET_GetBufferSubDataARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetBufferSubDataARB_remap_index], fn)
+#define CALL_IsBufferARB(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsBufferARB_remap_index], parameters)
+#define GET_IsBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[IsBufferARB_remap_index])
+#define SET_IsBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsBufferARB_remap_index], fn)
+#define CALL_MapBufferARB(disp, parameters) CALL_by_offset(disp, (GLvoid * (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[MapBufferARB_remap_index], parameters)
+#define GET_MapBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[MapBufferARB_remap_index])
+#define SET_MapBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MapBufferARB_remap_index], fn)
+#define CALL_UnmapBufferARB(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[UnmapBufferARB_remap_index], parameters)
+#define GET_UnmapBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[UnmapBufferARB_remap_index])
+#define SET_UnmapBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UnmapBufferARB_remap_index], fn)
+#define CALL_DepthBoundsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampd, GLclampd)), driDispatchRemapTable[DepthBoundsEXT_remap_index], parameters)
+#define GET_DepthBoundsEXT(disp) GET_by_offset(disp, driDispatchRemapTable[DepthBoundsEXT_remap_index])
+#define SET_DepthBoundsEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DepthBoundsEXT_remap_index], fn)
+#define CALL_GenQueriesARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenQueriesARB_remap_index], parameters)
+#define GET_GenQueriesARB(disp) GET_by_offset(disp, driDispatchRemapTable[GenQueriesARB_remap_index])
+#define SET_GenQueriesARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenQueriesARB_remap_index], fn)
+#define CALL_DeleteQueriesARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteQueriesARB_remap_index], parameters)
+#define GET_DeleteQueriesARB(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteQueriesARB_remap_index])
+#define SET_DeleteQueriesARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteQueriesARB_remap_index], fn)
+#define CALL_IsQueryARB(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsQueryARB_remap_index], parameters)
+#define GET_IsQueryARB(disp) GET_by_offset(disp, driDispatchRemapTable[IsQueryARB_remap_index])
+#define SET_IsQueryARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsQueryARB_remap_index], fn)
+#define CALL_BeginQueryARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BeginQueryARB_remap_index], parameters)
+#define GET_BeginQueryARB(disp) GET_by_offset(disp, driDispatchRemapTable[BeginQueryARB_remap_index])
+#define SET_BeginQueryARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BeginQueryARB_remap_index], fn)
+#define CALL_EndQueryARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[EndQueryARB_remap_index], parameters)
+#define GET_EndQueryARB(disp) GET_by_offset(disp, driDispatchRemapTable[EndQueryARB_remap_index])
+#define SET_EndQueryARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EndQueryARB_remap_index], fn)
+#define CALL_GetQueryivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetQueryivARB_remap_index], parameters)
+#define GET_GetQueryivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetQueryivARB_remap_index])
+#define SET_GetQueryivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetQueryivARB_remap_index], fn)
+#define CALL_GetQueryObjectivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetQueryObjectivARB_remap_index], parameters)
+#define GET_GetQueryObjectivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetQueryObjectivARB_remap_index])
+#define SET_GetQueryObjectivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetQueryObjectivARB_remap_index], fn)
+#define CALL_GetQueryObjectuivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLuint *)), driDispatchRemapTable[GetQueryObjectuivARB_remap_index], parameters)
+#define GET_GetQueryObjectuivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetQueryObjectuivARB_remap_index])
+#define SET_GetQueryObjectuivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetQueryObjectuivARB_remap_index], fn)
+#define CALL_MultiModeDrawArraysIBM(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLenum *, const GLint *, const GLsizei *, GLsizei, GLint)), driDispatchRemapTable[MultiModeDrawArraysIBM_remap_index], parameters)
+#define GET_MultiModeDrawArraysIBM(disp) GET_by_offset(disp, driDispatchRemapTable[MultiModeDrawArraysIBM_remap_index])
+#define SET_MultiModeDrawArraysIBM(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiModeDrawArraysIBM_remap_index], fn)
+#define CALL_MultiModeDrawElementsIBM(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLenum *, const GLsizei *, GLenum, const GLvoid * const *, GLsizei, GLint)), driDispatchRemapTable[MultiModeDrawElementsIBM_remap_index], parameters)
+#define GET_MultiModeDrawElementsIBM(disp) GET_by_offset(disp, driDispatchRemapTable[MultiModeDrawElementsIBM_remap_index])
+#define SET_MultiModeDrawElementsIBM(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiModeDrawElementsIBM_remap_index], fn)
+#define CALL_BlendEquationSeparateEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[BlendEquationSeparateEXT_remap_index], parameters)
+#define GET_BlendEquationSeparateEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BlendEquationSeparateEXT_remap_index])
+#define SET_BlendEquationSeparateEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BlendEquationSeparateEXT_remap_index], fn)
+#define CALL_DeleteObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[DeleteObjectARB_remap_index], parameters)
+#define GET_DeleteObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteObjectARB_remap_index])
+#define SET_DeleteObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteObjectARB_remap_index], fn)
+#define CALL_GetHandleARB(disp, parameters) CALL_by_offset(disp, (GLhandleARB (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[GetHandleARB_remap_index], parameters)
+#define GET_GetHandleARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetHandleARB_remap_index])
+#define SET_GetHandleARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHandleARB_remap_index], fn)
+#define CALL_DetachObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLhandleARB)), driDispatchRemapTable[DetachObjectARB_remap_index], parameters)
+#define GET_DetachObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[DetachObjectARB_remap_index])
+#define SET_DetachObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DetachObjectARB_remap_index], fn)
+#define CALL_CreateShaderObjectARB(disp, parameters) CALL_by_offset(disp, (GLhandleARB (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[CreateShaderObjectARB_remap_index], parameters)
+#define GET_CreateShaderObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[CreateShaderObjectARB_remap_index])
+#define SET_CreateShaderObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CreateShaderObjectARB_remap_index], fn)
+#define CALL_ShaderSourceARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, const GLcharARB **, const GLint *)), driDispatchRemapTable[ShaderSourceARB_remap_index], parameters)
+#define GET_ShaderSourceARB(disp) GET_by_offset(disp, driDispatchRemapTable[ShaderSourceARB_remap_index])
+#define SET_ShaderSourceARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ShaderSourceARB_remap_index], fn)
+#define CALL_CompileShaderARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[CompileShaderARB_remap_index], parameters)
+#define GET_CompileShaderARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompileShaderARB_remap_index])
+#define SET_CompileShaderARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompileShaderARB_remap_index], fn)
+#define CALL_CreateProgramObjectARB(disp, parameters) CALL_by_offset(disp, (GLhandleARB (GLAPIENTRYP)(void)), driDispatchRemapTable[CreateProgramObjectARB_remap_index], parameters)
+#define GET_CreateProgramObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[CreateProgramObjectARB_remap_index])
+#define SET_CreateProgramObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CreateProgramObjectARB_remap_index], fn)
+#define CALL_AttachObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLhandleARB)), driDispatchRemapTable[AttachObjectARB_remap_index], parameters)
+#define GET_AttachObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[AttachObjectARB_remap_index])
+#define SET_AttachObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AttachObjectARB_remap_index], fn)
+#define CALL_LinkProgramARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[LinkProgramARB_remap_index], parameters)
+#define GET_LinkProgramARB(disp) GET_by_offset(disp, driDispatchRemapTable[LinkProgramARB_remap_index])
+#define SET_LinkProgramARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LinkProgramARB_remap_index], fn)
+#define CALL_UseProgramObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[UseProgramObjectARB_remap_index], parameters)
+#define GET_UseProgramObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[UseProgramObjectARB_remap_index])
+#define SET_UseProgramObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UseProgramObjectARB_remap_index], fn)
+#define CALL_ValidateProgramARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[ValidateProgramARB_remap_index], parameters)
+#define GET_ValidateProgramARB(disp) GET_by_offset(disp, driDispatchRemapTable[ValidateProgramARB_remap_index])
+#define SET_ValidateProgramARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ValidateProgramARB_remap_index], fn)
+#define CALL_Uniform1fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat)), driDispatchRemapTable[Uniform1fARB_remap_index], parameters)
+#define GET_Uniform1fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1fARB_remap_index])
+#define SET_Uniform1fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1fARB_remap_index], fn)
+#define CALL_Uniform2fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat)), driDispatchRemapTable[Uniform2fARB_remap_index], parameters)
+#define GET_Uniform2fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2fARB_remap_index])
+#define SET_Uniform2fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2fARB_remap_index], fn)
+#define CALL_Uniform3fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[Uniform3fARB_remap_index], parameters)
+#define GET_Uniform3fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3fARB_remap_index])
+#define SET_Uniform3fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3fARB_remap_index], fn)
+#define CALL_Uniform4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[Uniform4fARB_remap_index], parameters)
+#define GET_Uniform4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4fARB_remap_index])
+#define SET_Uniform4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4fARB_remap_index], fn)
+#define CALL_Uniform1iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), driDispatchRemapTable[Uniform1iARB_remap_index], parameters)
+#define GET_Uniform1iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1iARB_remap_index])
+#define SET_Uniform1iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1iARB_remap_index], fn)
+#define CALL_Uniform2iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), driDispatchRemapTable[Uniform2iARB_remap_index], parameters)
+#define GET_Uniform2iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2iARB_remap_index])
+#define SET_Uniform2iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2iARB_remap_index], fn)
+#define CALL_Uniform3iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), driDispatchRemapTable[Uniform3iARB_remap_index], parameters)
+#define GET_Uniform3iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3iARB_remap_index])
+#define SET_Uniform3iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3iARB_remap_index], fn)
+#define CALL_Uniform4iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint, GLint)), driDispatchRemapTable[Uniform4iARB_remap_index], parameters)
+#define GET_Uniform4iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4iARB_remap_index])
+#define SET_Uniform4iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4iARB_remap_index], fn)
+#define CALL_Uniform1fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform1fvARB_remap_index], parameters)
+#define GET_Uniform1fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1fvARB_remap_index])
+#define SET_Uniform1fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1fvARB_remap_index], fn)
+#define CALL_Uniform2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform2fvARB_remap_index], parameters)
+#define GET_Uniform2fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2fvARB_remap_index])
+#define SET_Uniform2fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2fvARB_remap_index], fn)
+#define CALL_Uniform3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform3fvARB_remap_index], parameters)
+#define GET_Uniform3fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3fvARB_remap_index])
+#define SET_Uniform3fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3fvARB_remap_index], fn)
+#define CALL_Uniform4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform4fvARB_remap_index], parameters)
+#define GET_Uniform4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4fvARB_remap_index])
+#define SET_Uniform4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4fvARB_remap_index], fn)
+#define CALL_Uniform1ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform1ivARB_remap_index], parameters)
+#define GET_Uniform1ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1ivARB_remap_index])
+#define SET_Uniform1ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1ivARB_remap_index], fn)
+#define CALL_Uniform2ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform2ivARB_remap_index], parameters)
+#define GET_Uniform2ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2ivARB_remap_index])
+#define SET_Uniform2ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2ivARB_remap_index], fn)
+#define CALL_Uniform3ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform3ivARB_remap_index], parameters)
+#define GET_Uniform3ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3ivARB_remap_index])
+#define SET_Uniform3ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3ivARB_remap_index], fn)
+#define CALL_Uniform4ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform4ivARB_remap_index], parameters)
+#define GET_Uniform4ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4ivARB_remap_index])
+#define SET_Uniform4ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4ivARB_remap_index], fn)
+#define CALL_UniformMatrix2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix2fvARB_remap_index], parameters)
+#define GET_UniformMatrix2fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix2fvARB_remap_index])
+#define SET_UniformMatrix2fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix2fvARB_remap_index], fn)
+#define CALL_UniformMatrix3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix3fvARB_remap_index], parameters)
+#define GET_UniformMatrix3fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix3fvARB_remap_index])
+#define SET_UniformMatrix3fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix3fvARB_remap_index], fn)
+#define CALL_UniformMatrix4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix4fvARB_remap_index], parameters)
+#define GET_UniformMatrix4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix4fvARB_remap_index])
+#define SET_UniformMatrix4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix4fvARB_remap_index], fn)
+#define CALL_GetObjectParameterfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLenum, GLfloat *)), driDispatchRemapTable[GetObjectParameterfvARB_remap_index], parameters)
+#define GET_GetObjectParameterfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetObjectParameterfvARB_remap_index])
+#define SET_GetObjectParameterfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetObjectParameterfvARB_remap_index], fn)
+#define CALL_GetObjectParameterivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLenum, GLint *)), driDispatchRemapTable[GetObjectParameterivARB_remap_index], parameters)
+#define GET_GetObjectParameterivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetObjectParameterivARB_remap_index])
+#define SET_GetObjectParameterivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetObjectParameterivARB_remap_index], fn)
+#define CALL_GetInfoLogARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *)), driDispatchRemapTable[GetInfoLogARB_remap_index], parameters)
+#define GET_GetInfoLogARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetInfoLogARB_remap_index])
+#define SET_GetInfoLogARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetInfoLogARB_remap_index], fn)
+#define CALL_GetAttachedObjectsARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLhandleARB *)), driDispatchRemapTable[GetAttachedObjectsARB_remap_index], parameters)
+#define GET_GetAttachedObjectsARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetAttachedObjectsARB_remap_index])
+#define SET_GetAttachedObjectsARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetAttachedObjectsARB_remap_index], fn)
+#define CALL_GetUniformLocationARB(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLhandleARB, const GLcharARB *)), driDispatchRemapTable[GetUniformLocationARB_remap_index], parameters)
+#define GET_GetUniformLocationARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetUniformLocationARB_remap_index])
+#define SET_GetUniformLocationARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetUniformLocationARB_remap_index], fn)
+#define CALL_GetActiveUniformARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *)), driDispatchRemapTable[GetActiveUniformARB_remap_index], parameters)
+#define GET_GetActiveUniformARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetActiveUniformARB_remap_index])
+#define SET_GetActiveUniformARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetActiveUniformARB_remap_index], fn)
+#define CALL_GetUniformfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLint, GLfloat *)), driDispatchRemapTable[GetUniformfvARB_remap_index], parameters)
+#define GET_GetUniformfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetUniformfvARB_remap_index])
+#define SET_GetUniformfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetUniformfvARB_remap_index], fn)
+#define CALL_GetUniformivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLint, GLint *)), driDispatchRemapTable[GetUniformivARB_remap_index], parameters)
+#define GET_GetUniformivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetUniformivARB_remap_index])
+#define SET_GetUniformivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetUniformivARB_remap_index], fn)
+#define CALL_GetShaderSourceARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *)), driDispatchRemapTable[GetShaderSourceARB_remap_index], parameters)
+#define GET_GetShaderSourceARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetShaderSourceARB_remap_index])
+#define SET_GetShaderSourceARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetShaderSourceARB_remap_index], fn)
+#define CALL_BindAttribLocationARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLuint, const GLcharARB *)), driDispatchRemapTable[BindAttribLocationARB_remap_index], parameters)
+#define GET_BindAttribLocationARB(disp) GET_by_offset(disp, driDispatchRemapTable[BindAttribLocationARB_remap_index])
+#define SET_BindAttribLocationARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindAttribLocationARB_remap_index], fn)
+#define CALL_GetActiveAttribARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *)), driDispatchRemapTable[GetActiveAttribARB_remap_index], parameters)
+#define GET_GetActiveAttribARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetActiveAttribARB_remap_index])
+#define SET_GetActiveAttribARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetActiveAttribARB_remap_index], fn)
+#define CALL_GetAttribLocationARB(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLhandleARB, const GLcharARB *)), driDispatchRemapTable[GetAttribLocationARB_remap_index], parameters)
+#define GET_GetAttribLocationARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetAttribLocationARB_remap_index])
+#define SET_GetAttribLocationARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetAttribLocationARB_remap_index], fn)
+#define CALL_GetVertexAttribdvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLdouble *)), driDispatchRemapTable[GetVertexAttribdvNV_remap_index], parameters)
+#define GET_GetVertexAttribdvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvNV_remap_index])
+#define SET_GetVertexAttribdvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvNV_remap_index], fn)
+#define CALL_GetVertexAttribfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetVertexAttribfvNV_remap_index], parameters)
+#define GET_GetVertexAttribfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvNV_remap_index])
+#define SET_GetVertexAttribfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvNV_remap_index], fn)
+#define CALL_GetVertexAttribivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetVertexAttribivNV_remap_index], parameters)
+#define GET_GetVertexAttribivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivNV_remap_index])
+#define SET_GetVertexAttribivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivNV_remap_index], fn)
+#define CALL_VertexAttrib1dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble)), driDispatchRemapTable[VertexAttrib1dNV_remap_index], parameters)
+#define GET_VertexAttrib1dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dNV_remap_index])
+#define SET_VertexAttrib1dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dNV_remap_index], fn)
+#define CALL_VertexAttrib1dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib1dvNV_remap_index], parameters)
+#define GET_VertexAttrib1dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvNV_remap_index])
+#define SET_VertexAttrib1dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvNV_remap_index], fn)
+#define CALL_VertexAttrib1fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat)), driDispatchRemapTable[VertexAttrib1fNV_remap_index], parameters)
+#define GET_VertexAttrib1fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fNV_remap_index])
+#define SET_VertexAttrib1fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fNV_remap_index], fn)
+#define CALL_VertexAttrib1fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib1fvNV_remap_index], parameters)
+#define GET_VertexAttrib1fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvNV_remap_index])
+#define SET_VertexAttrib1fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvNV_remap_index], fn)
+#define CALL_VertexAttrib1sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort)), driDispatchRemapTable[VertexAttrib1sNV_remap_index], parameters)
+#define GET_VertexAttrib1sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sNV_remap_index])
+#define SET_VertexAttrib1sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sNV_remap_index], fn)
+#define CALL_VertexAttrib1svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib1svNV_remap_index], parameters)
+#define GET_VertexAttrib1svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svNV_remap_index])
+#define SET_VertexAttrib1svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svNV_remap_index], fn)
+#define CALL_VertexAttrib2dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib2dNV_remap_index], parameters)
+#define GET_VertexAttrib2dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dNV_remap_index])
+#define SET_VertexAttrib2dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dNV_remap_index], fn)
+#define CALL_VertexAttrib2dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib2dvNV_remap_index], parameters)
+#define GET_VertexAttrib2dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvNV_remap_index])
+#define SET_VertexAttrib2dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvNV_remap_index], fn)
+#define CALL_VertexAttrib2fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib2fNV_remap_index], parameters)
+#define GET_VertexAttrib2fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fNV_remap_index])
+#define SET_VertexAttrib2fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fNV_remap_index], fn)
+#define CALL_VertexAttrib2fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib2fvNV_remap_index], parameters)
+#define GET_VertexAttrib2fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvNV_remap_index])
+#define SET_VertexAttrib2fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvNV_remap_index], fn)
+#define CALL_VertexAttrib2sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib2sNV_remap_index], parameters)
+#define GET_VertexAttrib2sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sNV_remap_index])
+#define SET_VertexAttrib2sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sNV_remap_index], fn)
+#define CALL_VertexAttrib2svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib2svNV_remap_index], parameters)
+#define GET_VertexAttrib2svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svNV_remap_index])
+#define SET_VertexAttrib2svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svNV_remap_index], fn)
+#define CALL_VertexAttrib3dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib3dNV_remap_index], parameters)
+#define GET_VertexAttrib3dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dNV_remap_index])
+#define SET_VertexAttrib3dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dNV_remap_index], fn)
+#define CALL_VertexAttrib3dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib3dvNV_remap_index], parameters)
+#define GET_VertexAttrib3dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvNV_remap_index])
+#define SET_VertexAttrib3dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvNV_remap_index], fn)
+#define CALL_VertexAttrib3fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib3fNV_remap_index], parameters)
+#define GET_VertexAttrib3fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fNV_remap_index])
+#define SET_VertexAttrib3fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fNV_remap_index], fn)
+#define CALL_VertexAttrib3fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib3fvNV_remap_index], parameters)
+#define GET_VertexAttrib3fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvNV_remap_index])
+#define SET_VertexAttrib3fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvNV_remap_index], fn)
+#define CALL_VertexAttrib3sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib3sNV_remap_index], parameters)
+#define GET_VertexAttrib3sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sNV_remap_index])
+#define SET_VertexAttrib3sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sNV_remap_index], fn)
+#define CALL_VertexAttrib3svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib3svNV_remap_index], parameters)
+#define GET_VertexAttrib3svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svNV_remap_index])
+#define SET_VertexAttrib3svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svNV_remap_index], fn)
+#define CALL_VertexAttrib4dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib4dNV_remap_index], parameters)
+#define GET_VertexAttrib4dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dNV_remap_index])
+#define SET_VertexAttrib4dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dNV_remap_index], fn)
+#define CALL_VertexAttrib4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib4dvNV_remap_index], parameters)
+#define GET_VertexAttrib4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvNV_remap_index])
+#define SET_VertexAttrib4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvNV_remap_index], fn)
+#define CALL_VertexAttrib4fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib4fNV_remap_index], parameters)
+#define GET_VertexAttrib4fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fNV_remap_index])
+#define SET_VertexAttrib4fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fNV_remap_index], fn)
+#define CALL_VertexAttrib4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib4fvNV_remap_index], parameters)
+#define GET_VertexAttrib4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvNV_remap_index])
+#define SET_VertexAttrib4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvNV_remap_index], fn)
+#define CALL_VertexAttrib4sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib4sNV_remap_index], parameters)
+#define GET_VertexAttrib4sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sNV_remap_index])
+#define SET_VertexAttrib4sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sNV_remap_index], fn)
+#define CALL_VertexAttrib4svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib4svNV_remap_index], parameters)
+#define GET_VertexAttrib4svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svNV_remap_index])
+#define SET_VertexAttrib4svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svNV_remap_index], fn)
+#define CALL_VertexAttrib4ubNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte)), driDispatchRemapTable[VertexAttrib4ubNV_remap_index], parameters)
+#define GET_VertexAttrib4ubNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubNV_remap_index])
+#define SET_VertexAttrib4ubNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubNV_remap_index], fn)
+#define CALL_VertexAttrib4ubvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLubyte *)), driDispatchRemapTable[VertexAttrib4ubvNV_remap_index], parameters)
+#define GET_VertexAttrib4ubvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvNV_remap_index])
+#define SET_VertexAttrib4ubvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvNV_remap_index], fn)
+#define CALL_GenFragmentShadersATI(disp, parameters) CALL_by_offset(disp, (GLuint (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[GenFragmentShadersATI_remap_index], parameters)
+#define GET_GenFragmentShadersATI(disp) GET_by_offset(disp, driDispatchRemapTable[GenFragmentShadersATI_remap_index])
+#define SET_GenFragmentShadersATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenFragmentShadersATI_remap_index], fn)
+#define CALL_BindFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[BindFragmentShaderATI_remap_index], parameters)
+#define GET_BindFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[BindFragmentShaderATI_remap_index])
+#define SET_BindFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindFragmentShaderATI_remap_index], fn)
+#define CALL_DeleteFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[DeleteFragmentShaderATI_remap_index], parameters)
+#define GET_DeleteFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteFragmentShaderATI_remap_index])
+#define SET_DeleteFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteFragmentShaderATI_remap_index], fn)
+#define CALL_BeginFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[BeginFragmentShaderATI_remap_index], parameters)
+#define GET_BeginFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[BeginFragmentShaderATI_remap_index])
+#define SET_BeginFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BeginFragmentShaderATI_remap_index], fn)
+#define CALL_EndFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[EndFragmentShaderATI_remap_index], parameters)
+#define GET_EndFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[EndFragmentShaderATI_remap_index])
+#define SET_EndFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EndFragmentShaderATI_remap_index], fn)
+#define CALL_PassTexCoordATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLenum)), driDispatchRemapTable[PassTexCoordATI_remap_index], parameters)
+#define GET_PassTexCoordATI(disp) GET_by_offset(disp, driDispatchRemapTable[PassTexCoordATI_remap_index])
+#define SET_PassTexCoordATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PassTexCoordATI_remap_index], fn)
+#define CALL_SampleMapATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLenum)), driDispatchRemapTable[SampleMapATI_remap_index], parameters)
+#define GET_SampleMapATI(disp) GET_by_offset(disp, driDispatchRemapTable[SampleMapATI_remap_index])
+#define SET_SampleMapATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SampleMapATI_remap_index], fn)
+#define CALL_ColorFragmentOp1ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[ColorFragmentOp1ATI_remap_index], parameters)
+#define GET_ColorFragmentOp1ATI(disp) GET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp1ATI_remap_index])
+#define SET_ColorFragmentOp1ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp1ATI_remap_index], fn)
+#define CALL_ColorFragmentOp2ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[ColorFragmentOp2ATI_remap_index], parameters)
+#define GET_ColorFragmentOp2ATI(disp) GET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp2ATI_remap_index])
+#define SET_ColorFragmentOp2ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp2ATI_remap_index], fn)
+#define CALL_ColorFragmentOp3ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[ColorFragmentOp3ATI_remap_index], parameters)
+#define GET_ColorFragmentOp3ATI(disp) GET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp3ATI_remap_index])
+#define SET_ColorFragmentOp3ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp3ATI_remap_index], fn)
+#define CALL_AlphaFragmentOp1ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[AlphaFragmentOp1ATI_remap_index], parameters)
+#define GET_AlphaFragmentOp1ATI(disp) GET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp1ATI_remap_index])
+#define SET_AlphaFragmentOp1ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp1ATI_remap_index], fn)
+#define CALL_AlphaFragmentOp2ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[AlphaFragmentOp2ATI_remap_index], parameters)
+#define GET_AlphaFragmentOp2ATI(disp) GET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp2ATI_remap_index])
+#define SET_AlphaFragmentOp2ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp2ATI_remap_index], fn)
+#define CALL_AlphaFragmentOp3ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[AlphaFragmentOp3ATI_remap_index], parameters)
+#define GET_AlphaFragmentOp3ATI(disp) GET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp3ATI_remap_index])
+#define SET_AlphaFragmentOp3ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp3ATI_remap_index], fn)
+#define CALL_SetFragmentShaderConstantATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[SetFragmentShaderConstantATI_remap_index], parameters)
+#define GET_SetFragmentShaderConstantATI(disp) GET_by_offset(disp, driDispatchRemapTable[SetFragmentShaderConstantATI_remap_index])
+#define SET_SetFragmentShaderConstantATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SetFragmentShaderConstantATI_remap_index], fn)
+#define CALL_IsRenderbufferEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsRenderbufferEXT_remap_index], parameters)
+#define GET_IsRenderbufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IsRenderbufferEXT_remap_index])
+#define SET_IsRenderbufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsRenderbufferEXT_remap_index], fn)
+#define CALL_BindRenderbufferEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindRenderbufferEXT_remap_index], parameters)
+#define GET_BindRenderbufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindRenderbufferEXT_remap_index])
+#define SET_BindRenderbufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindRenderbufferEXT_remap_index], fn)
+#define CALL_DeleteRenderbuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteRenderbuffersEXT_remap_index], parameters)
+#define GET_DeleteRenderbuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteRenderbuffersEXT_remap_index])
+#define SET_DeleteRenderbuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteRenderbuffersEXT_remap_index], fn)
+#define CALL_GenRenderbuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenRenderbuffersEXT_remap_index], parameters)
+#define GET_GenRenderbuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenRenderbuffersEXT_remap_index])
+#define SET_GenRenderbuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenRenderbuffersEXT_remap_index], fn)
+#define CALL_RenderbufferStorageEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei)), driDispatchRemapTable[RenderbufferStorageEXT_remap_index], parameters)
+#define GET_RenderbufferStorageEXT(disp) GET_by_offset(disp, driDispatchRemapTable[RenderbufferStorageEXT_remap_index])
+#define SET_RenderbufferStorageEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[RenderbufferStorageEXT_remap_index], fn)
+#define CALL_GetRenderbufferParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetRenderbufferParameterivEXT_remap_index], parameters)
+#define GET_GetRenderbufferParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetRenderbufferParameterivEXT_remap_index])
+#define SET_GetRenderbufferParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetRenderbufferParameterivEXT_remap_index], fn)
+#define CALL_IsFramebufferEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsFramebufferEXT_remap_index], parameters)
+#define GET_IsFramebufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IsFramebufferEXT_remap_index])
+#define SET_IsFramebufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsFramebufferEXT_remap_index], fn)
+#define CALL_BindFramebufferEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindFramebufferEXT_remap_index], parameters)
+#define GET_BindFramebufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindFramebufferEXT_remap_index])
+#define SET_BindFramebufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindFramebufferEXT_remap_index], fn)
+#define CALL_DeleteFramebuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteFramebuffersEXT_remap_index], parameters)
+#define GET_DeleteFramebuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteFramebuffersEXT_remap_index])
+#define SET_DeleteFramebuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteFramebuffersEXT_remap_index], fn)
+#define CALL_GenFramebuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenFramebuffersEXT_remap_index], parameters)
+#define GET_GenFramebuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenFramebuffersEXT_remap_index])
+#define SET_GenFramebuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenFramebuffersEXT_remap_index], fn)
+#define CALL_CheckFramebufferStatusEXT(disp, parameters) CALL_by_offset(disp, (GLenum (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[CheckFramebufferStatusEXT_remap_index], parameters)
+#define GET_CheckFramebufferStatusEXT(disp) GET_by_offset(disp, driDispatchRemapTable[CheckFramebufferStatusEXT_remap_index])
+#define SET_CheckFramebufferStatusEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CheckFramebufferStatusEXT_remap_index], fn)
+#define CALL_FramebufferTexture1DEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint)), driDispatchRemapTable[FramebufferTexture1DEXT_remap_index], parameters)
+#define GET_FramebufferTexture1DEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferTexture1DEXT_remap_index])
+#define SET_FramebufferTexture1DEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferTexture1DEXT_remap_index], fn)
+#define CALL_FramebufferTexture2DEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint)), driDispatchRemapTable[FramebufferTexture2DEXT_remap_index], parameters)
+#define GET_FramebufferTexture2DEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferTexture2DEXT_remap_index])
+#define SET_FramebufferTexture2DEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferTexture2DEXT_remap_index], fn)
+#define CALL_FramebufferTexture3DEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint, GLint)), driDispatchRemapTable[FramebufferTexture3DEXT_remap_index], parameters)
+#define GET_FramebufferTexture3DEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferTexture3DEXT_remap_index])
+#define SET_FramebufferTexture3DEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferTexture3DEXT_remap_index], fn)
+#define CALL_FramebufferRenderbufferEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint)), driDispatchRemapTable[FramebufferRenderbufferEXT_remap_index], parameters)
+#define GET_FramebufferRenderbufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferRenderbufferEXT_remap_index])
+#define SET_FramebufferRenderbufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferRenderbufferEXT_remap_index], fn)
+#define CALL_GetFramebufferAttachmentParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFramebufferAttachmentParameterivEXT_remap_index], parameters)
+#define GET_GetFramebufferAttachmentParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetFramebufferAttachmentParameterivEXT_remap_index])
+#define SET_GetFramebufferAttachmentParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFramebufferAttachmentParameterivEXT_remap_index], fn)
+#define CALL_GenerateMipmapEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[GenerateMipmapEXT_remap_index], parameters)
+#define GET_GenerateMipmapEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenerateMipmapEXT_remap_index])
+#define SET_GenerateMipmapEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenerateMipmapEXT_remap_index], fn)
+#define CALL_StencilFuncSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLuint)), driDispatchRemapTable[StencilFuncSeparate_remap_index], parameters)
+#define GET_StencilFuncSeparate(disp) GET_by_offset(disp, driDispatchRemapTable[StencilFuncSeparate_remap_index])
+#define SET_StencilFuncSeparate(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StencilFuncSeparate_remap_index], fn)
+#define CALL_StencilOpSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[StencilOpSeparate_remap_index], parameters)
+#define GET_StencilOpSeparate(disp) GET_by_offset(disp, driDispatchRemapTable[StencilOpSeparate_remap_index])
+#define SET_StencilOpSeparate(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StencilOpSeparate_remap_index], fn)
+#define CALL_StencilMaskSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[StencilMaskSeparate_remap_index], parameters)
+#define GET_StencilMaskSeparate(disp) GET_by_offset(disp, driDispatchRemapTable[StencilMaskSeparate_remap_index])
+#define SET_StencilMaskSeparate(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StencilMaskSeparate_remap_index], fn)
+
+#endif /* !defined(IN_DRI_DRIVER) */
+
 #endif /* !defined( _DISPATCH_H_ ) */

diff --git a/src/mesa/glapi/extension_helper.py b/src/mesa/glapi/extension_helper.py
index 21f5b56fbbd9a56e0d996af775b9923281c88d89..a2a16a8b3646c8df829d87d831d6c9e90886b1ee 100644 (file)
--- a/src/mesa/glapi/extension_helper.py
+++ b/src/mesa/glapi/extension_helper.py
@@ -102,6 +102,24 @@ vtxfmt = [
     "EvalMesh2", \
 ]
 
+def all_entrypoints_in_abi(f, abi, api):
+       for n in f.entry_points:
+               [category, num] = api.get_category_for_name( n )
+               if category not in abi:
+                       return 0
+
+       return 1
+
+
+def any_entrypoints_in_abi(f, abi, api):
+       for n in f.entry_points:
+               [category, num] = api.get_category_for_name( n )
+               if category in abi:
+                       return 1
+
+       return 0
+
+
 def condition_for_function(f, abi, all_not_in_ABI):
        """Create a C-preprocessor condition for the function.
        
@@ -133,6 +151,7 @@ class PrintGlExtensionGlue(gl_XML.gl_print_base):
 
        def printRealHeader(self):
                print '#include "utils.h"'
+               print '#include "dispatch.h"'
                print ''
                return
 
@@ -178,7 +197,7 @@ class PrintGlExtensionGlue(gl_XML.gl_print_base):
                                                if not category_list.has_key(c):
                                                        category_list[ c ] = []
 
-                                               category_list[ c ].append( [f.name, f.offset] )
+                                               category_list[ c ].append( f )
 
                                print '    "";'
                                print '#endif'
@@ -190,9 +209,17 @@ class PrintGlExtensionGlue(gl_XML.gl_print_base):
                for category in keys:
                        print '#if defined(need_%s)' % (category)
                        print 'static const struct dri_extension_function %s_functions[] = {' % (category)
-                       for [function, offset] in category_list[ category ]:
-                               print '    { %s_names, %d },' % (function, offset)
-                       print '    { NULL, 0 }'
+                       
+                       for f in category_list[ category ]:
+                               if any_entrypoints_in_abi(f, abi, api):
+                                       index_name = "-1"
+                               else:
+                                       index_name = "%s_remap_index" % (f.name)
+
+                               print '    { %s_names, %s, %d },' % (f.name, index_name, f.offset)
+
+
+                       print '    { NULL, 0, 0 }'
                        print '};'
                        print '#endif'
                        print ''

diff --git a/src/mesa/glapi/gl_offsets.py b/src/mesa/glapi/gl_offsets.py
index dfd7fda9d77ad3c6f468a98c24a7d0e9c893fe2c..6f6be2069c2cc5c22eb6298c39df9d1f7a83c88d 100644 (file)
--- a/src/mesa/glapi/gl_offsets.py
+++ b/src/mesa/glapi/gl_offsets.py
@@ -41,8 +41,14 @@ class PrintGlOffsets(gl_XML.gl_print_base):
                return
 
        def printBody(self, api):
+               last_static = 0
                for f in api.functionIterateByOffset():
                        print '#define _gloffset_%s %d' % (f.name, f.offset)
+                       if f.offset > last_static:
+                               last_static = f.offset
+
+               print '#define _gloffset_FIRST_DYNAMIC %d' % (last_static + 1)
+               return
 
 
 def show_usage():

diff --git a/src/mesa/glapi/gl_table.py b/src/mesa/glapi/gl_table.py
index d585b43cde54983ad487575746e843b867b627c9..864ac8a8c3e2627f861b32c2e2337cdfbf7cf5de 100644 (file)
--- a/src/mesa/glapi/gl_table.py
+++ b/src/mesa/glapi/gl_table.py
@@ -52,6 +52,8 @@ class PrintGlTable(gl_XML.gl_print_base):
                print '#define GLAPIENTRYP'
                print '#endif'
                print ''
+               print 'typedef void (*_glapi_proc)(void); /* generic function pointer */'
+               print ''
                print 'struct _glapi_table'
                print '{'
                return
@@ -93,15 +95,9 @@ class PrintRemapTable(gl_XML.gl_print_base):
                print '#define GET_by_offset(disp, offset) \\'
                print '    (((_glapi_proc *)(disp))[offset])'
                print '#define SET_by_offset(disp, offset, fn) \\'
-               print '    ((((_glapi_proc *)(disp))[offset]) = fn)'
+               print '    ((((_glapi_proc *)(disp))[offset]) = (_glapi_proc) fn)'
                print ''
 
-               for f in api.functionIterateByOffset():
-                       print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name)
-                       print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name)
-                       print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name)
-               return
-
                abi = [ "1.0", "1.1", "1.2", "GL_ARB_multitexture" ]
 
                functions = []
@@ -116,26 +112,44 @@ class PrintRemapTable(gl_XML.gl_print_base):
                                abi_functions.append( f )
 
 
-               print 'struct _mesa_dispatch_remap_table {'
+               for f in abi_functions:
+                       print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name)
+                       print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name)
+                       print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name)
+
+
+               print ''
+               print '#if !defined(IN_DRI_DRIVER)'
+               print ''
 
                for [f, index] in functions:
-                       print '   unsigned %s;' % (f.name)
+                       print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name)
+                       print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name)
+                       print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name)
 
-               print '};'
                print ''
-               print '/* %u functions need remapping. */' % (count)
+               print '#else'
+               print ''
+               print '#define driDispatchRemapTable_size %u' % (count)
+               print 'extern unsigned driDispatchRemapTable[ driDispatchRemapTable_size ];'
                print ''
 
-               for f in abi_functions:
-                       print '#define CALL_%s(disp, parameters) (*disp->%s) parameters' % (f.name, f.name)
+               for [f, index] in functions:
+                       print '#define %s_remap_index %u' % (f.name, index)
 
+               print ''
 
                for [f, index] in functions:
                        arg_string = gl_XML.create_parameter_string( f.parameters, 0 )
                        cast = '%s (GLAPIENTRYP)(%s)' % (f.return_type, arg_string)
 
-                       print '#define CALL_%s(disp, parameters) (* (%s) (((_glapi_proc *)disp)[dispatch_remap.%s])) parameters' % (f.name, cast, f.name)
+                       print '#define CALL_%s(disp, parameters) CALL_by_offset(disp, (%s), driDispatchRemapTable[%s_remap_index], parameters)' % (f.name, cast, f.name)
+                       print '#define GET_%s(disp) GET_by_offset(disp, driDispatchRemapTable[%s_remap_index])' % (f.name, f.name)
+                       print '#define SET_%s(disp, fn) SET_by_offset(disp, driDispatchRemapTable[%s_remap_index], fn)' % (f.name, f.name)
+
 
+               print ''
+               print '#endif /* !defined(IN_DRI_DRIVER) */'
                return
 
 

diff --git a/src/mesa/glapi/glapi.c b/src/mesa/glapi/glapi.c
index 5132bebaef5e0e67890895a536e09ff95389038d..47a1f164582fb77de2d52f435eb43e93b28814aa 100644 (file)
--- a/src/mesa/glapi/glapi.c
+++ b/src/mesa/glapi/glapi.c
@@ -671,14 +671,52 @@ get_static_proc_name( GLuint offset )
 #define DISPATCH_TABLE_SIZE (sizeof(struct _glapi_table) / sizeof(void *) + MAX_EXTENSION_FUNCS)
 
 
-struct name_address_offset {
-   const char *Name;
-   _glapi_proc Address;
-   GLuint Offset;
+/**
+ * Track information about a function added to the GL API.
+ */
+struct _glapi_function {
+   /**
+    * Name of the function.
+    */
+   const char * name;
+
+
+   /**
+    * Text string that describes the types of the parameters passed to the
+    * named function.   Parameter types are converted to characters using the
+    * following rules:
+    *   - 'i' for \c GLint, \c GLuint, and \c GLenum
+    *   - 'p' for any pointer type
+    *   - 'f' for \c GLfloat and \c GLclampf
+    *   - 'd' for \c GLdouble and \c GLclampd
+    */
+   const char * parameter_signature;
+
+
+   /**
+    * Offset in the dispatch table where the pointer to the real function is
+    * located.  If the driver has not requested that the named function be
+    * added to the dispatch table, this will have the value ~0.
+    */
+   unsigned dispatch_offset;
+
+
+   /**
+    * Pointer to the dispatch stub for the named function.
+    * 
+    * \todo
+    * The semantic of this field should be changed slightly.  Currently, it
+    * is always expected to be non-\c NULL.  However, it would be better to
+    * only allocate the entry-point stub when the application requests the
+    * function via \c glXGetProcAddress.  This would save memory for all the
+    * functions that the driver exports but that the application never wants
+    * to call.
+    */
+   _glapi_proc dispatch_stub;
 };
 
 
-static struct name_address_offset ExtEntryTable[MAX_EXTENSION_FUNCS];
+static struct _glapi_function ExtEntryTable[MAX_EXTENSION_FUNCS];
 static GLuint NumExtEntryPoints = 0;
 
 #ifdef USE_SPARC_ASM
@@ -814,76 +852,189 @@ fill_in_entrypoint_offset(_glapi_proc entrypoint, GLuint offset)
 
 
 /**
- * Add a new extension function entrypoint.
- * Return: GL_TRUE = success or GL_FALSE = failure
+ * Generate new entrypoint
+ *
+ * Use a temporary dispatch offset of ~0 (i.e. -1).  Later, when the driver
+ * calls \c _glapi_add_dispatch we'll put in the proper offset.  If that
+ * never happens, and the user calls this function, he'll segfault.  That's
+ * what you get when you try calling a GL function that doesn't really exist.
+ * 
+ * \param funcName  Name of the function to create an entry-point for.
+ * 
+ * \sa _glapi_add_entrypoint
  */
-PUBLIC GLboolean
-_glapi_add_entrypoint(const char *funcName, GLuint offset)
+
+static struct _glapi_function *
+add_function_name( const char * funcName )
 {
-   /* trivial rejection test */
+   struct _glapi_function * entry = NULL;
+   
+   if (NumExtEntryPoints < MAX_EXTENSION_FUNCS) {
+      _glapi_proc entrypoint = generate_entrypoint(~0);
+      if (entrypoint != NULL) {
+        entry = & ExtEntryTable[NumExtEntryPoints];
+
+        ExtEntryTable[NumExtEntryPoints].name = str_dup(funcName);
+        ExtEntryTable[NumExtEntryPoints].parameter_signature = NULL;
+        ExtEntryTable[NumExtEntryPoints].dispatch_offset = ~0;
+        ExtEntryTable[NumExtEntryPoints].dispatch_stub = entrypoint;
+        NumExtEntryPoints++;
+      }
+   }
+
+   return entry;
+}
+
+
+/**
+ * Fill-in the dispatch stub for the named function.
+ * 
+ * This function is intended to be called by a hardware driver.  When called,
+ * a dispatch stub may be created created for the function.  A pointer to this
+ * dispatch function will be returned by glXGetProcAddress.
+ *
+ * \param function_names       Array of pointers to function names that should
+ *                             share a common dispatch offset.
+ * \param parameter_signature  String representing the types of the parameters
+ *                             passed to the named function.  Parameter types
+ *                             are converted to characters using the following
+ *                             rules:
+ *                               - 'i' for \c GLint, \c GLuint, and \c GLenum
+ *                               - 'p' for any pointer type
+ *                               - 'f' for \c GLfloat and \c GLclampf
+ *                               - 'd' for \c GLdouble and \c GLclampd
+ *
+ * \returns
+ * The offset in the dispatch table of the named function.  A pointer to the
+ * driver's implementation of the named function should be stored at
+ * \c dispatch_table[\c offset].
+ *
+ * \sa glXGetProcAddress
+ *
+ * \warning
+ * This function can only handle up to 8 names at a time.  As far as I know,
+ * the maximum number of names ever associated with an existing GL function is
+ * 4 (\c glPointParameterfSGIS, \c glPointParameterfEXT,
+ * \c glPointParameterfARB, and \c glPointParameterf), so this should not be
+ * too painful of a limitation.
+ *
+ * \todo
+ * Determine whether or not \c parameter_signature should be allowed to be
+ * \c NULL.  It doesn't seem like much of a hardship for drivers to have to
+ * pass in an empty string.
+ *
+ * \todo
+ * Determine if code should be added to reject function names that start with
+ * 'glX'.
+ * 
+ * \bug
+ * Add code to compare \c parameter_signature with the parameter signature of
+ * a static function.  In order to do that, we need to find a way to \b get
+ * the parameter signature of a static function.
+ */
+
+PUBLIC int
+_glapi_add_dispatch( const char * const * function_names,
+                    const char * parameter_signature )
+{
+   static int next_dynamic_offset = _gloffset_FIRST_DYNAMIC;
+   const char * const real_sig = (parameter_signature != NULL)
+     ? parameter_signature : "";
+   struct _glapi_function * entry[8];
+   GLboolean is_static[8];
+   unsigned i;
+   unsigned j;
+   int offset = ~0;
+   int new_offset;
+
+
+   (void) memset( is_static, 0, sizeof( is_static ) );
+   (void) memset( entry, 0, sizeof( entry ) );
+
+   for ( i = 0 ; function_names[i] != NULL ; i++ ) {
+      /* Do some trivial validation on the name of the function.
+       */
+
 #ifdef MANGLE
-   if (!funcName || funcName[0] != 'm' || funcName[1] != 'g' || funcName[2] != 'l')
-      return GL_FALSE;
+      if (!function_names[i] || function_names[i][0] != 'm' || function_names[i][1] != 'g' || function_names[i][2] != 'l')
+       return GL_FALSE;
 #else
-   if (!funcName || funcName[0] != 'g' || funcName[1] != 'l')
-      return GL_FALSE;
+      if (!function_names[i] || function_names[i][0] != 'g' || function_names[i][1] != 'l')
+       return GL_FALSE;
 #endif
-
-   /* first check if the named function is already statically present */
-   {
-      GLint index = get_static_proc_offset(funcName);
-      if (index >= 0) {
-         return (GLboolean) ((GLuint) index == offset);  /* bad offset! */
+   
+   
+      /* Determine if the named function already exists.  If the function does
+       * exist, it must have the same parameter signature as the function
+       * being added.
+       */
+
+      new_offset = get_static_proc_offset(function_names[i]);
+      if (new_offset >= 0) {
+        /* FIXME: Make sure the parameter signatures match!  How do we get
+         * FIXME: the parameter signature for static functions?
+         */
+
+        if ( (offset != ~0) && (new_offset != offset) ) {
+           return -1;
+        }
+
+        is_static[i] = GL_TRUE;
+        offset = new_offset;
       }
-   }
-
-   /* See if this function has already been dynamically added */
-   {
-      GLuint i;
-      for (i = 0; i < NumExtEntryPoints; i++) {
-         if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
-            /* function already registered */
-            if (ExtEntryTable[i].Offset == offset) {
-               return GL_TRUE;  /* offsets match */
-            }
-            else if (ExtEntryTable[i].Offset == (GLuint) ~0
-                     && offset < DISPATCH_TABLE_SIZE) {
-               /* need to patch-up the dispatch code */
-               if (offset != (GLuint) ~0) {
-                  fill_in_entrypoint_offset(ExtEntryTable[i].Address, offset);
-                  ExtEntryTable[i].Offset = offset;
-               }
-               return GL_TRUE;
-            }
-            else {
-               return GL_FALSE;  /* bad offset! */
-            }
-         }
+   
+   
+      for ( j = 0 ; j < NumExtEntryPoints ; j++ ) {
+        if (strcmp(ExtEntryTable[j].name, function_names[i]) == 0) {
+           /* The offset may be ~0 if the function name was added by
+            * glXGetProcAddress but never filled in by the driver.
+            */
+
+           if (ExtEntryTable[j].dispatch_offset != ~0) {
+              if (strcmp(real_sig, ExtEntryTable[j].parameter_signature) 
+                  != 0) {
+                 return -1;
+              }
+
+              if ( (offset != ~0) && (ExtEntryTable[j].dispatch_offset != offset) ) {
+                 return -1;
+              }
+
+              offset = ExtEntryTable[j].dispatch_offset;
+           }
+           
+           entry[i] = & ExtEntryTable[j];
+           break;
+        }
       }
    }
 
-   /* This is a new function, try to add it.  */
-   if (NumExtEntryPoints >= MAX_EXTENSION_FUNCS ||
-       offset >= DISPATCH_TABLE_SIZE) {
-      /* No space left */
-      return GL_FALSE;
+
+   if (offset == ~0) {
+      offset = next_dynamic_offset;
+      next_dynamic_offset++;
    }
-   else {
-      _glapi_proc entrypoint = generate_entrypoint(offset);
-      if (!entrypoint)
-         return GL_FALSE; /* couldn't generate assembly */
 
-      /* OK! */
-      ExtEntryTable[NumExtEntryPoints].Name = str_dup(funcName);
-      ExtEntryTable[NumExtEntryPoints].Offset = offset;
-      ExtEntryTable[NumExtEntryPoints].Address = entrypoint;
-      NumExtEntryPoints++;
 
-      return GL_TRUE;  /* success */
-   }
+   for ( i = 0 ; function_names[i] != NULL ; i++ ) {
+      if (! is_static[i] ) {
+        if (entry[i] == NULL) {
+           entry[i] = add_function_name( function_names[i] );
+           if (entry[i] == NULL) {
+              /* FIXME: Possible memory leak here.
+               */
+              return -1;
+           }
+        }
+
 
-   /* should never get here, silence compiler warnings */
-   return GL_FALSE;
+        entry[i]->parameter_signature = str_dup(real_sig);
+        fill_in_entrypoint_offset(entry[i]->dispatch_stub, offset);
+        entry[i]->dispatch_offset = offset;
+      }
+   }
+   
+   return offset;
 }
 
 
@@ -896,8 +1047,8 @@ _glapi_get_proc_offset(const char *funcName)
    /* search extension functions first */
    GLuint i;
    for (i = 0; i < NumExtEntryPoints; i++) {
-      if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
-         return ExtEntryTable[i].Offset;
+      if (strcmp(ExtEntryTable[i].name, funcName) == 0) {
+         return ExtEntryTable[i].dispatch_offset;
       }
    }
 
@@ -915,6 +1066,7 @@ _glapi_get_proc_offset(const char *funcName)
 PUBLIC _glapi_proc
 _glapi_get_proc_address(const char *funcName)
 {
+   struct _glapi_function * entry;
    GLuint i;
 
 #ifdef MANGLE
@@ -927,8 +1079,8 @@ _glapi_get_proc_address(const char *funcName)
 
    /* search extension functions first */
    for (i = 0; i < NumExtEntryPoints; i++) {
-      if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
-         return ExtEntryTable[i].Address;
+      if (strcmp(ExtEntryTable[i].name, funcName) == 0) {
+         return ExtEntryTable[i].dispatch_stub;
       }
    }
 
@@ -939,28 +1091,8 @@ _glapi_get_proc_address(const char *funcName)
          return func;
    }
 
-   /* generate new entrypoint - use a temporary dispatch offset of
-    * ~0 (i.e. -1).  Later, when the driver calls _glapi_add_entrypoint()
-    * we'll put in the proper offset.  If that never happens, and the
-    * user calls this function, he'll segfault.  That's what you get
-    * when you try calling a GL function that doesn't really exist.
-    */
-   if (NumExtEntryPoints < MAX_EXTENSION_FUNCS) {
-      _glapi_proc entrypoint = generate_entrypoint(~0);
-      if (!entrypoint)
-         return GL_FALSE;
-
-      ExtEntryTable[NumExtEntryPoints].Name = str_dup(funcName);
-      ExtEntryTable[NumExtEntryPoints].Offset = ~0;
-      ExtEntryTable[NumExtEntryPoints].Address = entrypoint;
-      NumExtEntryPoints++;
-
-      return entrypoint;
-   }
-   else {
-      /* no space for new functions! */
-      return NULL;
-   }
+   entry = add_function_name(funcName);
+   return (entry == NULL) ? NULL : entry->dispatch_stub;
 }
 
 
@@ -983,8 +1115,8 @@ _glapi_get_proc_name(GLuint offset)
 
    /* search added extension functions */
    for (i = 0; i < NumExtEntryPoints; i++) {
-      if (ExtEntryTable[i].Offset == offset) {
-         return ExtEntryTable[i].Name;
+      if (ExtEntryTable[i].dispatch_offset == offset) {
+         return ExtEntryTable[i].name;
       }
    }
    return NULL;

diff --git a/src/mesa/glapi/glapi.h b/src/mesa/glapi/glapi.h
index c334203394f1203487316124662a792685c512e2..eb26ebf87b5055c7f50c1348b63c06b980222641 100644 (file)
--- a/src/mesa/glapi/glapi.h
+++ b/src/mesa/glapi/glapi.h
@@ -46,13 +46,10 @@
 
 
 #include "GL/gl.h"
-
-struct _glapi_table;
+#include "glapitable.h"
 
 typedef void (*_glapi_warning_func)(void *ctx, const char *str, ...);
 
-typedef void (*_glapi_proc)(void); /* generic function pointer */
-
 
 #if defined (GLX_USE_TLS)
 
@@ -140,9 +137,9 @@ extern void
 _glapi_check_table(const struct _glapi_table *table);
 
 
-extern GLboolean
-_glapi_add_entrypoint(const char *funcName, GLuint offset);
-
+extern int
+_glapi_add_dispatch( const char * const * function_names,
+                    const char * parameter_signature );
 
 extern GLint
 _glapi_get_proc_offset(const char *funcName);

diff --git a/src/mesa/glapi/glapioffsets.h b/src/mesa/glapi/glapioffsets.h
index f7e9c95bd8841814b99d8706548b896d8ed54446..262b69e67dd9433fff6c8761c41c39958dafc989 100644 (file)
--- a/src/mesa/glapi/glapioffsets.h
+++ b/src/mesa/glapi/glapioffsets.h
@@ -845,5 +845,6 @@
 #define _gloffset_StencilFuncSeparate 813
 #define _gloffset_StencilOpSeparate 814
 #define _gloffset_StencilMaskSeparate 815
+#define _gloffset_FIRST_DYNAMIC 816
 
 #endif /* !defined( _GLAPI_OFFSETS_H_ ) */

diff --git a/src/mesa/glapi/glapitable.h b/src/mesa/glapi/glapitable.h
index a450311e625c8458089d9bbd23e0532c63da1997..b4c70bdaae93c4fad552af944e719880e856e6a5 100644 (file)
--- a/src/mesa/glapi/glapitable.h
+++ b/src/mesa/glapi/glapitable.h
@@ -33,6 +33,8 @@
 #define GLAPIENTRYP
 #endif
 
+typedef void (*_glapi_proc)(void); /* generic function pointer */
+
 struct _glapi_table
 {
    void (GLAPIENTRYP NewList)(GLuint list, GLenum mode); /* 0 */

diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 6c036da8743c8ea18a9be3f8bdeeed2e9f6281f3..956fc9971e82eeabef35441cf66df0ade105dc8f 100644 (file)
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -2598,7 +2598,10 @@ struct gl_tnl_module
     * On restore, only need to swap these functions back in.
     */
    /*@{*/
-   void *Swapped[NUM_VERTEX_FORMAT_ENTRIES][2];
+   struct {
+       _glapi_proc * location;
+       _glapi_proc function;
+   } Swapped[NUM_VERTEX_FORMAT_ENTRIES];
    GLuint SwapCount;
    /*@}*/
 };

diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c
index 0d285cb26c981cc25adf270360665d7ebee9d832..dcb684837c8dda620e49f1ce7f9735014f1576d2 100644 (file)
--- a/src/mesa/main/vtxfmt.c
+++ b/src/mesa/main/vtxfmt.c
@@ -49,15 +49,14 @@
 {                                                                      \
    GET_CURRENT_CONTEXT(ctx);                                           \
    struct gl_tnl_module *tnl = &(ctx->TnlModule);                      \
-   typedef void (*func_ptr_t)(void);                                   \
                                                                        \
    ASSERT( tnl->Current );                                             \
    ASSERT( tnl->SwapCount < NUM_VERTEX_FORMAT_ENTRIES );               \
                                                                        \
    /* Save the swapped function's dispatch entry so it can be */       \
    /* restored later. */                                               \
-   tnl->Swapped[tnl->SwapCount][0] = (void *)&(GET_ ## FUNC (ctx->Exec)); \
-   *(func_ptr_t *)(tnl->Swapped[tnl->SwapCount]+1) = (func_ptr_t)TAG(FUNC);    \
+   tnl->Swapped[tnl->SwapCount].location = (_glapi_proc *) & (GET_ ## FUNC (ctx->Exec)); \
+   tnl->Swapped[tnl->SwapCount].function = (_glapi_proc)TAG(FUNC);     \
    tnl->SwapCount++;                                                   \
                                                                        \
    if ( 0 )                                                            \
@@ -177,7 +176,7 @@ void _mesa_restore_exec_vtxfmt( GLcontext *ctx )
    /* Restore the neutral tnl module wrapper.
     */
    for ( i = 0 ; i < tnl->SwapCount ; i++ ) {
-      *(void **)tnl->Swapped[i][0] = tnl->Swapped[i][1];
+      *(tnl->Swapped[i].location) = tnl->Swapped[i].function;
    }
 
    tnl->SwapCount = 0;