src/mesa/glapi/glapi.c

   1 /* $Id: glapi.c,v 1.41 2000/05/18 18:14:22 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.3
   6  *
   7  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 /*
  29  * This file manages the OpenGL API dispatch layer.
  30  * The dispatch table (struct _glapi_table) is basically just a list
  31  * of function pointers.
  32  * There are functions to set/get the current dispatch table for the
  33  * current thread and to manage registration/dispatch of dynamically
  34  * added extension functions.
  35  *
  36  * It's intended that this file and the other glapi*.[ch] files are
  37  * flexible enough to be reused in several places:  XFree86, DRI-
  38  * based libGL.so, and perhaps the SGI SI.
  39  *
  40  * There are no dependencies on Mesa in this code.
  41  */
  42
  43
  44
  45 #include "glheader.h"
  46 #include "glapi.h"
  47 #include "glapinoop.h"
  48 #include "glapioffsets.h"
  49 #include "glapitable.h"
  50 #include "glthread.h"
  51
  52
  53 /* This is used when thread safety is disabled */
  54 struct _glapi_table *_glapi_Dispatch = (struct _glapi_table *) __glapi_noop_table;
  55
  56 /* Used when thread safety disabled */
  57 void *_glapi_Context = NULL;
  58
  59
  60 #if defined(THREADS)
  61
  62 /* Flag to indicate whether thread-safe dispatch is enabled */
  63 static GLboolean ThreadSafe = GL_FALSE;
  64
  65 static _glthread_TSD DispatchTSD;
  66
  67 static _glthread_TSD ContextTSD;
  68
  69 #endif
  70
  71
  72
  73 static GLuint MaxDispatchOffset = sizeof(struct _glapi_table) / sizeof(void *) - 1;
  74 static GLboolean GetSizeCalled = GL_FALSE;
  75
  76 /* strdup is actually not a standard ANSI C or POSIX routine
  77    Irix will not define it if ANSI mode is in effect. */
  78 static char *str_dup(const char *str)
  79 {
  80    char *copy;
  81    copy = (char*) malloc(strlen(str) + 1);
  82    if (!copy)
  83       return NULL;
  84    strcpy(copy, str);
  85    return copy;
  86 }
  87
  88
  89
  90 /*
  91  * We should call this periodically from a function such as glXMakeCurrent
  92  * in order to test if multiple threads are being used.  When we detect
  93  * that situation we should then call _glapi_enable_thread_safety()
  94  */
  95 void
  96 _glapi_check_multithread(void)
  97 {
  98 #if defined(THREADS)
  99    if (!ThreadSafe) {
 100       static unsigned long knownID;
 101       static GLboolean firstCall = GL_TRUE;
 102       if (firstCall) {
 103          knownID = _glthread_GetID();
 104          firstCall = GL_FALSE;
 105       }
 106       else if (knownID != _glthread_GetID()) {
 107          ThreadSafe = GL_TRUE;
 108       }
 109    }
 110    if (ThreadSafe) {
 111       /* make sure that this thread's dispatch pointer isn't null */
 112       if (!_glapi_get_dispatch()) {
 113          _glapi_set_dispatch(NULL);
 114       }
 115    }
 116 #endif
 117 }
 118
 119
 120
 121 /*
 122  * Set the current context pointer for this thread.
 123  * The context pointer is an opaque type which should be cast to
 124  * void from the real context pointer type.
 125  */
 126 void
 127 _glapi_set_context(void *context)
 128 {
 129 #if defined(THREADS)
 130    _glthread_SetTSD(&ContextTSD, context);
 131    if (ThreadSafe)
 132       _glapi_Context = NULL;
 133    else
 134       _glapi_Context = context;
 135 #else
 136    _glapi_Context = context;
 137 #endif
 138 }
 139
 140
 141
 142 /*
 143  * Get the current context pointer for this thread.
 144  * The context pointer is an opaque type which should be cast from
 145  * void to the real context pointer type.
 146  */
 147 void *
 148 _glapi_get_context(void)
 149 {
 150 #if defined(THREADS)
 151    if (ThreadSafe) {
 152       return _glthread_GetTSD(&ContextTSD);
 153    }
 154    else {
 155       return _glapi_Context;
 156    }
 157 #else
 158    return _glapi_Context;
 159 #endif
 160 }
 161
 162
 163
 164 /*
 165  * Set the global or per-thread dispatch table pointer.
 166  */
 167 void
 168 _glapi_set_dispatch(struct _glapi_table *dispatch)
 169 {
 170    if (!dispatch) {
 171       /* use the no-op functions */
 172       dispatch = (struct _glapi_table *) __glapi_noop_table;
 173    }
 174 #ifdef DEBUG
 175    else {
 176       _glapi_check_table(dispatch);
 177    }
 178 #endif
 179
 180 #if defined(THREADS)
 181    _glthread_SetTSD(&DispatchTSD, (void*) dispatch);
 182    if (ThreadSafe)
 183       _glapi_Dispatch = NULL;
 184    else
 185       _glapi_Dispatch = dispatch;
 186 #else
 187    _glapi_Dispatch = dispatch;
 188 #endif
 189 }
 190
 191
 192
 193 /*
 194  * Return pointer to current dispatch table for calling thread.
 195  */
 196 struct _glapi_table *
 197 _glapi_get_dispatch(void)
 198 {
 199 #if defined(THREADS)
 200    if (ThreadSafe) {
 201       return (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);
 202    }
 203    else {
 204       assert(_glapi_Dispatch);
 205       return _glapi_Dispatch;
 206    }
 207 #else
 208    return _glapi_Dispatch;
 209 #endif
 210 }
 211
 212
 213
 214 /*
 215  * Return size of dispatch table struct as number of functions (or
 216  * slots).
 217  */
 218 GLuint
 219 _glapi_get_dispatch_table_size(void)
 220 {
 221    /*   return sizeof(struct _glapi_table) / sizeof(void *);*/
 222    GetSizeCalled = GL_TRUE;
 223    return MaxDispatchOffset + 1;
 224 }
 225
 226
 227
 228 /*
 229  * Get API dispatcher version string.
 230  */
 231 const char *
 232 _glapi_get_version(void)
 233 {
 234    return "20000223";  /* YYYYMMDD */
 235 }
 236
 237
 238 /*
 239  * For each entry in static_functions[] which use this function
 240  * we should implement a dispatch function in glapitemp.h and
 241  * in glapinoop.c
 242  */
 243 static int NotImplemented(void)
 244 {
 245    return 0;
 246 }
 247
 248
 249 struct name_address_offset {
 250    const char *Name;
 251    GLvoid *Address;
 252    GLuint Offset;
 253 };
 254
 255
 256 static struct name_address_offset static_functions[] = {
 257         /* GL 1.1 */
 258         { "glNewList", (GLvoid *) glNewList, _gloffset_NewList },
 259         { "glEndList", (GLvoid *) glEndList, _gloffset_EndList },
 260         { "glCallList", (GLvoid *) glCallList, _gloffset_CallList },
 261         { "glCallLists", (GLvoid *) glCallLists, _gloffset_CallLists },
 262         { "glDeleteLists", (GLvoid *) glDeleteLists, _gloffset_DeleteLists },
 263         { "glGenLists", (GLvoid *) glGenLists, _gloffset_GenLists },
 264         { "glListBase", (GLvoid *) glListBase, _gloffset_ListBase },
 265         { "glBegin", (GLvoid *) glBegin, _gloffset_Begin },
 266         { "glBitmap", (GLvoid *) glBitmap, _gloffset_Bitmap },
 267         { "glColor3b", (GLvoid *) glColor3b, _gloffset_Color3b },
 268         { "glColor3bv", (GLvoid *) glColor3bv, _gloffset_Color3bv },
 269         { "glColor3d", (GLvoid *) glColor3d, _gloffset_Color3d },
 270         { "glColor3dv", (GLvoid *) glColor3dv, _gloffset_Color3dv },
 271         { "glColor3f", (GLvoid *) glColor3f, _gloffset_Color3f },
 272         { "glColor3fv", (GLvoid *) glColor3fv, _gloffset_Color3fv },
 273         { "glColor3i", (GLvoid *) glColor3i, _gloffset_Color3i },
 274         { "glColor3iv", (GLvoid *) glColor3iv, _gloffset_Color3iv },
 275         { "glColor3s", (GLvoid *) glColor3s, _gloffset_Color3s },
 276         { "glColor3sv", (GLvoid *) glColor3sv, _gloffset_Color3sv },
 277         { "glColor3ub", (GLvoid *) glColor3ub, _gloffset_Color3ub },
 278         { "glColor3ubv", (GLvoid *) glColor3ubv, _gloffset_Color3ubv },
 279         { "glColor3ui", (GLvoid *) glColor3ui, _gloffset_Color3ui },
 280         { "glColor3uiv", (GLvoid *) glColor3uiv, _gloffset_Color3uiv },
 281         { "glColor3us", (GLvoid *) glColor3us, _gloffset_Color3us },
 282         { "glColor3usv", (GLvoid *) glColor3usv, _gloffset_Color3usv },
 283         { "glColor4b", (GLvoid *) glColor4b, _gloffset_Color4b },
 284         { "glColor4bv", (GLvoid *) glColor4bv, _gloffset_Color4bv },
 285         { "glColor4d", (GLvoid *) glColor4d, _gloffset_Color4d },
 286         { "glColor4dv", (GLvoid *) glColor4dv, _gloffset_Color4dv },
 287         { "glColor4f", (GLvoid *) glColor4f, _gloffset_Color4f },
 288         { "glColor4fv", (GLvoid *) glColor4fv, _gloffset_Color4fv },
 289         { "glColor4i", (GLvoid *) glColor4i, _gloffset_Color4i },
 290         { "glColor4iv", (GLvoid *) glColor4iv, _gloffset_Color4iv },
 291         { "glColor4s", (GLvoid *) glColor4s, _gloffset_Color4s },
 292         { "glColor4sv", (GLvoid *) glColor4sv, _gloffset_Color4sv },
 293         { "glColor4ub", (GLvoid *) glColor4ub, _gloffset_Color4ub },
 294         { "glColor4ubv", (GLvoid *) glColor4ubv, _gloffset_Color4ubv },
 295         { "glColor4ui", (GLvoid *) glColor4ui, _gloffset_Color4ui },
 296         { "glColor4uiv", (GLvoid *) glColor4uiv, _gloffset_Color4uiv },
 297         { "glColor4us", (GLvoid *) glColor4us, _gloffset_Color4us },
 298         { "glColor4usv", (GLvoid *) glColor4usv, _gloffset_Color4usv },
 299         { "glEdgeFlag", (GLvoid *) glEdgeFlag, _gloffset_EdgeFlag },
 300         { "glEdgeFlagv", (GLvoid *) glEdgeFlagv, _gloffset_EdgeFlagv },
 301         { "glEnd", (GLvoid *) glEnd, _gloffset_End },
 302         { "glIndexd", (GLvoid *) glIndexd, _gloffset_Indexd },
 303         { "glIndexdv", (GLvoid *) glIndexdv, _gloffset_Indexdv },
 304         { "glIndexf", (GLvoid *) glIndexf, _gloffset_Indexf },
 305         { "glIndexfv", (GLvoid *) glIndexfv, _gloffset_Indexfv },
 306         { "glIndexi", (GLvoid *) glIndexi, _gloffset_Indexi },
 307         { "glIndexiv", (GLvoid *) glIndexiv, _gloffset_Indexiv },
 308         { "glIndexs", (GLvoid *) glIndexs, _gloffset_Indexs },
 309         { "glIndexsv", (GLvoid *) glIndexsv, _gloffset_Indexsv },
 310         { "glNormal3b", (GLvoid *) glNormal3b, _gloffset_Normal3b },
 311         { "glNormal3bv", (GLvoid *) glNormal3bv, _gloffset_Normal3bv },
 312         { "glNormal3d", (GLvoid *) glNormal3d, _gloffset_Normal3d },
 313         { "glNormal3dv", (GLvoid *) glNormal3dv, _gloffset_Normal3dv },
 314         { "glNormal3f", (GLvoid *) glNormal3f, _gloffset_Normal3f },
 315         { "glNormal3fv", (GLvoid *) glNormal3fv, _gloffset_Normal3fv },
 316         { "glNormal3i", (GLvoid *) glNormal3i, _gloffset_Normal3i },
 317         { "glNormal3iv", (GLvoid *) glNormal3iv, _gloffset_Normal3iv },
 318         { "glNormal3s", (GLvoid *) glNormal3s, _gloffset_Normal3s },
 319         { "glNormal3sv", (GLvoid *) glNormal3sv, _gloffset_Normal3sv },
 320         { "glRasterPos2d", (GLvoid *) glRasterPos2d, _gloffset_RasterPos2d },
 321         { "glRasterPos2dv", (GLvoid *) glRasterPos2dv, _gloffset_RasterPos2dv },
 322         { "glRasterPos2f", (GLvoid *) glRasterPos2f, _gloffset_RasterPos2f },
 323         { "glRasterPos2fv", (GLvoid *) glRasterPos2fv, _gloffset_RasterPos2fv },
 324         { "glRasterPos2i", (GLvoid *) glRasterPos2i, _gloffset_RasterPos2i },
 325         { "glRasterPos2iv", (GLvoid *) glRasterPos2iv, _gloffset_RasterPos2iv },
 326         { "glRasterPos2s", (GLvoid *) glRasterPos2s, _gloffset_RasterPos2s },
 327         { "glRasterPos2sv", (GLvoid *) glRasterPos2sv, _gloffset_RasterPos2sv },
 328         { "glRasterPos3d", (GLvoid *) glRasterPos3d, _gloffset_RasterPos3d },
 329         { "glRasterPos3dv", (GLvoid *) glRasterPos3dv, _gloffset_RasterPos3dv },
 330         { "glRasterPos3f", (GLvoid *) glRasterPos3f, _gloffset_RasterPos3f },
 331         { "glRasterPos3fv", (GLvoid *) glRasterPos3fv, _gloffset_RasterPos3fv },
 332         { "glRasterPos3i", (GLvoid *) glRasterPos3i, _gloffset_RasterPos3i },
 333         { "glRasterPos3iv", (GLvoid *) glRasterPos3iv, _gloffset_RasterPos3iv },
 334         { "glRasterPos3s", (GLvoid *) glRasterPos3s, _gloffset_RasterPos3s },
 335         { "glRasterPos3sv", (GLvoid *) glRasterPos3sv, _gloffset_RasterPos3sv },
 336         { "glRasterPos4d", (GLvoid *) glRasterPos4d, _gloffset_RasterPos4d },
 337         { "glRasterPos4dv", (GLvoid *) glRasterPos4dv, _gloffset_RasterPos4dv },
 338         { "glRasterPos4f", (GLvoid *) glRasterPos4f, _gloffset_RasterPos4f },
 339         { "glRasterPos4fv", (GLvoid *) glRasterPos4fv, _gloffset_RasterPos4fv },
 340         { "glRasterPos4i", (GLvoid *) glRasterPos4i, _gloffset_RasterPos4i },
 341         { "glRasterPos4iv", (GLvoid *) glRasterPos4iv, _gloffset_RasterPos4iv },
 342         { "glRasterPos4s", (GLvoid *) glRasterPos4s, _gloffset_RasterPos4s },
 343         { "glRasterPos4sv", (GLvoid *) glRasterPos4sv, _gloffset_RasterPos4sv },
 344         { "glRectd", (GLvoid *) glRectd, _gloffset_Rectd },
 345         { "glRectdv", (GLvoid *) glRectdv, _gloffset_Rectdv },
 346         { "glRectf", (GLvoid *) glRectf, _gloffset_Rectf },
 347         { "glRectfv", (GLvoid *) glRectfv, _gloffset_Rectfv },
 348         { "glRecti", (GLvoid *) glRecti, _gloffset_Recti },
 349         { "glRectiv", (GLvoid *) glRectiv, _gloffset_Rectiv },
 350         { "glRects", (GLvoid *) glRects, _gloffset_Rects },
 351         { "glRectsv", (GLvoid *) glRectsv, _gloffset_Rectsv },
 352         { "glTexCoord1d", (GLvoid *) glTexCoord1d, _gloffset_TexCoord1d },
 353         { "glTexCoord1dv", (GLvoid *) glTexCoord1dv, _gloffset_TexCoord1dv },
 354         { "glTexCoord1f", (GLvoid *) glTexCoord1f, _gloffset_TexCoord1f },
 355         { "glTexCoord1fv", (GLvoid *) glTexCoord1fv, _gloffset_TexCoord1fv },
 356         { "glTexCoord1i", (GLvoid *) glTexCoord1i, _gloffset_TexCoord1i },
 357         { "glTexCoord1iv", (GLvoid *) glTexCoord1iv, _gloffset_TexCoord1iv },
 358         { "glTexCoord1s", (GLvoid *) glTexCoord1s, _gloffset_TexCoord1s },
 359         { "glTexCoord1sv", (GLvoid *) glTexCoord1sv, _gloffset_TexCoord1sv },
 360         { "glTexCoord2d", (GLvoid *) glTexCoord2d, _gloffset_TexCoord2d },
 361         { "glTexCoord2dv", (GLvoid *) glTexCoord2dv, _gloffset_TexCoord2dv },
 362         { "glTexCoord2f", (GLvoid *) glTexCoord2f, _gloffset_TexCoord2f },
 363         { "glTexCoord2fv", (GLvoid *) glTexCoord2fv, _gloffset_TexCoord2fv },
 364         { "glTexCoord2i", (GLvoid *) glTexCoord2i, _gloffset_TexCoord2i },
 365         { "glTexCoord2iv", (GLvoid *) glTexCoord2iv, _gloffset_TexCoord2iv },
 366         { "glTexCoord2s", (GLvoid *) glTexCoord2s, _gloffset_TexCoord2s },
 367         { "glTexCoord2sv", (GLvoid *) glTexCoord2sv, _gloffset_TexCoord2sv },
 368         { "glTexCoord3d", (GLvoid *) glTexCoord3d, _gloffset_TexCoord3d },
 369         { "glTexCoord3dv", (GLvoid *) glTexCoord3dv, _gloffset_TexCoord3dv },
 370         { "glTexCoord3f", (GLvoid *) glTexCoord3f, _gloffset_TexCoord3f },
 371         { "glTexCoord3fv", (GLvoid *) glTexCoord3fv, _gloffset_TexCoord3fv },
 372         { "glTexCoord3i", (GLvoid *) glTexCoord3i, _gloffset_TexCoord3i },
 373         { "glTexCoord3iv", (GLvoid *) glTexCoord3iv, _gloffset_TexCoord3iv },
 374         { "glTexCoord3s", (GLvoid *) glTexCoord3s, _gloffset_TexCoord3s },
 375         { "glTexCoord3sv", (GLvoid *) glTexCoord3sv, _gloffset_TexCoord3sv },
 376         { "glTexCoord4d", (GLvoid *) glTexCoord4d, _gloffset_TexCoord4d },
 377         { "glTexCoord4dv", (GLvoid *) glTexCoord4dv, _gloffset_TexCoord4dv },
 378         { "glTexCoord4f", (GLvoid *) glTexCoord4f, _gloffset_TexCoord4f },
 379         { "glTexCoord4fv", (GLvoid *) glTexCoord4fv, _gloffset_TexCoord4fv },
 380         { "glTexCoord4i", (GLvoid *) glTexCoord4i, _gloffset_TexCoord4i },
 381         { "glTexCoord4iv", (GLvoid *) glTexCoord4iv, _gloffset_TexCoord4iv },
 382         { "glTexCoord4s", (GLvoid *) glTexCoord4s, _gloffset_TexCoord4s },
 383         { "glTexCoord4sv", (GLvoid *) glTexCoord4sv, _gloffset_TexCoord4sv },
 384         { "glVertex2d", (GLvoid *) glVertex2d, _gloffset_Vertex2d },
 385         { "glVertex2dv", (GLvoid *) glVertex2dv, _gloffset_Vertex2dv },
 386         { "glVertex2f", (GLvoid *) glVertex2f, _gloffset_Vertex2f },
 387         { "glVertex2fv", (GLvoid *) glVertex2fv, _gloffset_Vertex2fv },
 388         { "glVertex2i", (GLvoid *) glVertex2i, _gloffset_Vertex2i },
 389         { "glVertex2iv", (GLvoid *) glVertex2iv, _gloffset_Vertex2iv },
 390         { "glVertex2s", (GLvoid *) glVertex2s, _gloffset_Vertex2s },
 391         { "glVertex2sv", (GLvoid *) glVertex2sv, _gloffset_Vertex2sv },
 392         { "glVertex3d", (GLvoid *) glVertex3d, _gloffset_Vertex3d },
 393         { "glVertex3dv", (GLvoid *) glVertex3dv, _gloffset_Vertex3dv },
 394         { "glVertex3f", (GLvoid *) glVertex3f, _gloffset_Vertex3f },
 395         { "glVertex3fv", (GLvoid *) glVertex3fv, _gloffset_Vertex3fv },
 396         { "glVertex3i", (GLvoid *) glVertex3i, _gloffset_Vertex3i },
 397         { "glVertex3iv", (GLvoid *) glVertex3iv, _gloffset_Vertex3iv },
 398         { "glVertex3s", (GLvoid *) glVertex3s, _gloffset_Vertex3s },
 399         { "glVertex3sv", (GLvoid *) glVertex3sv, _gloffset_Vertex3sv },
 400         { "glVertex4d", (GLvoid *) glVertex4d, _gloffset_Vertex4d },
 401         { "glVertex4dv", (GLvoid *) glVertex4dv, _gloffset_Vertex4dv },
 402         { "glVertex4f", (GLvoid *) glVertex4f, _gloffset_Vertex4f },
 403         { "glVertex4fv", (GLvoid *) glVertex4fv, _gloffset_Vertex4fv },
 404         { "glVertex4i", (GLvoid *) glVertex4i, _gloffset_Vertex4i },
 405         { "glVertex4iv", (GLvoid *) glVertex4iv, _gloffset_Vertex4iv },
 406         { "glVertex4s", (GLvoid *) glVertex4s, _gloffset_Vertex4s },
 407         { "glVertex4sv", (GLvoid *) glVertex4sv, _gloffset_Vertex4sv },
 408         { "glClipPlane", (GLvoid *) glClipPlane, _gloffset_ClipPlane },
 409         { "glColorMaterial", (GLvoid *) glColorMaterial, _gloffset_ColorMaterial },
 410         { "glCullFace", (GLvoid *) glCullFace, _gloffset_CullFace },
 411         { "glFogf", (GLvoid *) glFogf, _gloffset_Fogf },
 412         { "glFogfv", (GLvoid *) glFogfv, _gloffset_Fogfv },
 413         { "glFogi", (GLvoid *) glFogi, _gloffset_Fogi },
 414         { "glFogiv", (GLvoid *) glFogiv, _gloffset_Fogiv },
 415         { "glFrontFace", (GLvoid *) glFrontFace, _gloffset_FrontFace },
 416         { "glHint", (GLvoid *) glHint, _gloffset_Hint },
 417         { "glLightf", (GLvoid *) glLightf, _gloffset_Lightf },
 418         { "glLightfv", (GLvoid *) glLightfv, _gloffset_Lightfv },
 419         { "glLighti", (GLvoid *) glLighti, _gloffset_Lighti },
 420         { "glLightiv", (GLvoid *) glLightiv, _gloffset_Lightiv },
 421         { "glLightModelf", (GLvoid *) glLightModelf, _gloffset_LightModelf },
 422         { "glLightModelfv", (GLvoid *) glLightModelfv, _gloffset_LightModelfv },
 423         { "glLightModeli", (GLvoid *) glLightModeli, _gloffset_LightModeli },
 424         { "glLightModeliv", (GLvoid *) glLightModeliv, _gloffset_LightModeliv },
 425         { "glLineStipple", (GLvoid *) glLineStipple, _gloffset_LineStipple },
 426         { "glLineWidth", (GLvoid *) glLineWidth, _gloffset_LineWidth },
 427         { "glMaterialf", (GLvoid *) glMaterialf, _gloffset_Materialf },
 428         { "glMaterialfv", (GLvoid *) glMaterialfv, _gloffset_Materialfv },
 429         { "glMateriali", (GLvoid *) glMateriali, _gloffset_Materiali },
 430         { "glMaterialiv", (GLvoid *) glMaterialiv, _gloffset_Materialiv },
 431         { "glPointSize", (GLvoid *) glPointSize, _gloffset_PointSize },
 432         { "glPolygonMode", (GLvoid *) glPolygonMode, _gloffset_PolygonMode },
 433         { "glPolygonStipple", (GLvoid *) glPolygonStipple, _gloffset_PolygonStipple },
 434         { "glScissor", (GLvoid *) glScissor, _gloffset_Scissor },
 435         { "glShadeModel", (GLvoid *) glShadeModel, _gloffset_ShadeModel },
 436         { "glTexParameterf", (GLvoid *) glTexParameterf, _gloffset_TexParameterf },
 437         { "glTexParameterfv", (GLvoid *) glTexParameterfv, _gloffset_TexParameterfv },
 438         { "glTexParameteri", (GLvoid *) glTexParameteri, _gloffset_TexParameteri },
 439         { "glTexParameteriv", (GLvoid *) glTexParameteriv, _gloffset_TexParameteriv },
 440         { "glTexImage1D", (GLvoid *) glTexImage1D, _gloffset_TexImage1D },
 441         { "glTexImage2D", (GLvoid *) glTexImage2D, _gloffset_TexImage2D },
 442         { "glTexEnvf", (GLvoid *) glTexEnvf, _gloffset_TexEnvf },
 443         { "glTexEnvfv", (GLvoid *) glTexEnvfv, _gloffset_TexEnvfv },
 444         { "glTexEnvi", (GLvoid *) glTexEnvi, _gloffset_TexEnvi },
 445         { "glTexEnviv", (GLvoid *) glTexEnviv, _gloffset_TexEnviv },
 446         { "glTexGend", (GLvoid *) glTexGend, _gloffset_TexGend },
 447         { "glTexGendv", (GLvoid *) glTexGendv, _gloffset_TexGendv },
 448         { "glTexGenf", (GLvoid *) glTexGenf, _gloffset_TexGenf },
 449         { "glTexGenfv", (GLvoid *) glTexGenfv, _gloffset_TexGenfv },
 450         { "glTexGeni", (GLvoid *) glTexGeni, _gloffset_TexGeni },
 451         { "glTexGeniv", (GLvoid *) glTexGeniv, _gloffset_TexGeniv },
 452         { "glFeedbackBuffer", (GLvoid *) glFeedbackBuffer, _gloffset_FeedbackBuffer },
 453         { "glSelectBuffer", (GLvoid *) glSelectBuffer, _gloffset_SelectBuffer },
 454         { "glRenderMode", (GLvoid *) glRenderMode, _gloffset_RenderMode },
 455         { "glInitNames", (GLvoid *) glInitNames, _gloffset_InitNames },
 456         { "glLoadName", (GLvoid *) glLoadName, _gloffset_LoadName },
 457         { "glPassThrough", (GLvoid *) glPassThrough, _gloffset_PassThrough },
 458         { "glPopName", (GLvoid *) glPopName, _gloffset_PopName },
 459         { "glPushName", (GLvoid *) glPushName, _gloffset_PushName },
 460         { "glDrawBuffer", (GLvoid *) glDrawBuffer, _gloffset_DrawBuffer },
 461         { "glClear", (GLvoid *) glClear, _gloffset_Clear },
 462         { "glClearAccum", (GLvoid *) glClearAccum, _gloffset_ClearAccum },
 463         { "glClearIndex", (GLvoid *) glClearIndex, _gloffset_ClearIndex },
 464         { "glClearColor", (GLvoid *) glClearColor, _gloffset_ClearColor },
 465         { "glClearStencil", (GLvoid *) glClearStencil, _gloffset_ClearStencil },
 466         { "glClearDepth", (GLvoid *) glClearDepth, _gloffset_ClearDepth },
 467         { "glStencilMask", (GLvoid *) glStencilMask, _gloffset_StencilMask },
 468         { "glColorMask", (GLvoid *) glColorMask, _gloffset_ColorMask },
 469         { "glDepthMask", (GLvoid *) glDepthMask, _gloffset_DepthMask },
 470         { "glIndexMask", (GLvoid *) glIndexMask, _gloffset_IndexMask },
 471         { "glAccum", (GLvoid *) glAccum, _gloffset_Accum },
 472         { "glDisable", (GLvoid *) glDisable, _gloffset_Disable },
 473         { "glEnable", (GLvoid *) glEnable, _gloffset_Enable },
 474         { "glFinish", (GLvoid *) glFinish, _gloffset_Finish },
 475         { "glFlush", (GLvoid *) glFlush, _gloffset_Flush },
 476         { "glPopAttrib", (GLvoid *) glPopAttrib, _gloffset_PopAttrib },
 477         { "glPushAttrib", (GLvoid *) glPushAttrib, _gloffset_PushAttrib },
 478         { "glMap1d", (GLvoid *) glMap1d, _gloffset_Map1d },
 479         { "glMap1f", (GLvoid *) glMap1f, _gloffset_Map1f },
 480         { "glMap2d", (GLvoid *) glMap2d, _gloffset_Map2d },
 481         { "glMap2f", (GLvoid *) glMap2f, _gloffset_Map2f },
 482         { "glMapGrid1d", (GLvoid *) glMapGrid1d, _gloffset_MapGrid1d },
 483         { "glMapGrid1f", (GLvoid *) glMapGrid1f, _gloffset_MapGrid1f },
 484         { "glMapGrid2d", (GLvoid *) glMapGrid2d, _gloffset_MapGrid2d },
 485         { "glMapGrid2f", (GLvoid *) glMapGrid2f, _gloffset_MapGrid2f },
 486         { "glEvalCoord1d", (GLvoid *) glEvalCoord1d, _gloffset_EvalCoord1d },
 487         { "glEvalCoord1dv", (GLvoid *) glEvalCoord1dv, _gloffset_EvalCoord1dv },
 488         { "glEvalCoord1f", (GLvoid *) glEvalCoord1f, _gloffset_EvalCoord1f },
 489         { "glEvalCoord1fv", (GLvoid *) glEvalCoord1fv, _gloffset_EvalCoord1fv },
 490         { "glEvalCoord2d", (GLvoid *) glEvalCoord2d, _gloffset_EvalCoord2d },
 491         { "glEvalCoord2dv", (GLvoid *) glEvalCoord2dv, _gloffset_EvalCoord2dv },
 492         { "glEvalCoord2f", (GLvoid *) glEvalCoord2f, _gloffset_EvalCoord2f },
 493         { "glEvalCoord2fv", (GLvoid *) glEvalCoord2fv, _gloffset_EvalCoord2fv },
 494         { "glEvalMesh1", (GLvoid *) glEvalMesh1, _gloffset_EvalMesh1 },
 495         { "glEvalPoint1", (GLvoid *) glEvalPoint1, _gloffset_EvalPoint1 },
 496         { "glEvalMesh2", (GLvoid *) glEvalMesh2, _gloffset_EvalMesh2 },
 497         { "glEvalPoint2", (GLvoid *) glEvalPoint2, _gloffset_EvalPoint2 },
 498         { "glAlphaFunc", (GLvoid *) glAlphaFunc, _gloffset_AlphaFunc },
 499         { "glBlendFunc", (GLvoid *) glBlendFunc, _gloffset_BlendFunc },
 500         { "glLogicOp", (GLvoid *) glLogicOp, _gloffset_LogicOp },
 501         { "glStencilFunc", (GLvoid *) glStencilFunc, _gloffset_StencilFunc },
 502         { "glStencilOp", (GLvoid *) glStencilOp, _gloffset_StencilOp },
 503         { "glDepthFunc", (GLvoid *) glDepthFunc, _gloffset_DepthFunc },
 504         { "glPixelZoom", (GLvoid *) glPixelZoom, _gloffset_PixelZoom },
 505         { "glPixelTransferf", (GLvoid *) glPixelTransferf, _gloffset_PixelTransferf },
 506         { "glPixelTransferi", (GLvoid *) glPixelTransferi, _gloffset_PixelTransferi },
 507         { "glPixelStoref", (GLvoid *) glPixelStoref, _gloffset_PixelStoref },
 508         { "glPixelStorei", (GLvoid *) glPixelStorei, _gloffset_PixelStorei },
 509         { "glPixelMapfv", (GLvoid *) glPixelMapfv, _gloffset_PixelMapfv },
 510         { "glPixelMapuiv", (GLvoid *) glPixelMapuiv, _gloffset_PixelMapuiv },
 511         { "glPixelMapusv", (GLvoid *) glPixelMapusv, _gloffset_PixelMapusv },
 512         { "glReadBuffer", (GLvoid *) glReadBuffer, _gloffset_ReadBuffer },
 513         { "glCopyPixels", (GLvoid *) glCopyPixels, _gloffset_CopyPixels },
 514         { "glReadPixels", (GLvoid *) glReadPixels, _gloffset_ReadPixels },
 515         { "glDrawPixels", (GLvoid *) glDrawPixels, _gloffset_DrawPixels },
 516         { "glGetBooleanv", (GLvoid *) glGetBooleanv, _gloffset_GetBooleanv },
 517         { "glGetClipPlane", (GLvoid *) glGetClipPlane, _gloffset_GetClipPlane },
 518         { "glGetDoublev", (GLvoid *) glGetDoublev, _gloffset_GetDoublev },
 519         { "glGetError", (GLvoid *) glGetError, _gloffset_GetError },
 520         { "glGetFloatv", (GLvoid *) glGetFloatv, _gloffset_GetFloatv },
 521         { "glGetIntegerv", (GLvoid *) glGetIntegerv, _gloffset_GetIntegerv },
 522         { "glGetLightfv", (GLvoid *) glGetLightfv, _gloffset_GetLightfv },
 523         { "glGetLightiv", (GLvoid *) glGetLightiv, _gloffset_GetLightiv },
 524         { "glGetMapdv", (GLvoid *) glGetMapdv, _gloffset_GetMapdv },
 525         { "glGetMapfv", (GLvoid *) glGetMapfv, _gloffset_GetMapfv },
 526         { "glGetMapiv", (GLvoid *) glGetMapiv, _gloffset_GetMapiv },
 527         { "glGetMaterialfv", (GLvoid *) glGetMaterialfv, _gloffset_GetMaterialfv },
 528         { "glGetMaterialiv", (GLvoid *) glGetMaterialiv, _gloffset_GetMaterialiv },
 529         { "glGetPixelMapfv", (GLvoid *) glGetPixelMapfv, _gloffset_GetPixelMapfv },
 530         { "glGetPixelMapuiv", (GLvoid *) glGetPixelMapuiv, _gloffset_GetPixelMapuiv },
 531         { "glGetPixelMapusv", (GLvoid *) glGetPixelMapusv, _gloffset_GetPixelMapusv },
 532         { "glGetPolygonStipple", (GLvoid *) glGetPolygonStipple, _gloffset_GetPolygonStipple },
 533         { "glGetString", (GLvoid *) glGetString, _gloffset_GetString },
 534         { "glGetTexEnvfv", (GLvoid *) glGetTexEnvfv, _gloffset_GetTexEnvfv },
 535         { "glGetTexEnviv", (GLvoid *) glGetTexEnviv, _gloffset_GetTexEnviv },
 536         { "glGetTexGendv", (GLvoid *) glGetTexGendv, _gloffset_GetTexGendv },
 537         { "glGetTexGenfv", (GLvoid *) glGetTexGenfv, _gloffset_GetTexGenfv },
 538         { "glGetTexGeniv", (GLvoid *) glGetTexGeniv, _gloffset_GetTexGeniv },
 539         { "glGetTexImage", (GLvoid *) glGetTexImage, _gloffset_GetTexImage },
 540         { "glGetTexParameterfv", (GLvoid *) glGetTexParameterfv, _gloffset_GetTexParameterfv },
 541         { "glGetTexParameteriv", (GLvoid *) glGetTexParameteriv, _gloffset_GetTexParameteriv },
 542         { "glGetTexLevelParameterfv", (GLvoid *) glGetTexLevelParameterfv, _gloffset_GetTexLevelParameterfv },
 543         { "glGetTexLevelParameteriv", (GLvoid *) glGetTexLevelParameteriv, _gloffset_GetTexLevelParameteriv },
 544         { "glIsEnabled", (GLvoid *) glIsEnabled, _gloffset_IsEnabled },
 545         { "glIsList", (GLvoid *) glIsList, _gloffset_IsList },
 546         { "glDepthRange", (GLvoid *) glDepthRange, _gloffset_DepthRange },
 547         { "glFrustum", (GLvoid *) glFrustum, _gloffset_Frustum },
 548         { "glLoadIdentity", (GLvoid *) glLoadIdentity, _gloffset_LoadIdentity },
 549         { "glLoadMatrixf", (GLvoid *) glLoadMatrixf, _gloffset_LoadMatrixf },
 550         { "glLoadMatrixd", (GLvoid *) glLoadMatrixd, _gloffset_LoadMatrixd },
 551         { "glMatrixMode", (GLvoid *) glMatrixMode, _gloffset_MatrixMode },
 552         { "glMultMatrixf", (GLvoid *) glMultMatrixf, _gloffset_MultMatrixf },
 553         { "glMultMatrixd", (GLvoid *) glMultMatrixd, _gloffset_MultMatrixd },
 554         { "glOrtho", (GLvoid *) glOrtho, _gloffset_Ortho },
 555         { "glPopMatrix", (GLvoid *) glPopMatrix, _gloffset_PopMatrix },
 556         { "glPushMatrix", (GLvoid *) glPushMatrix, _gloffset_PushMatrix },
 557         { "glRotated", (GLvoid *) glRotated, _gloffset_Rotated },
 558         { "glRotatef", (GLvoid *) glRotatef, _gloffset_Rotatef },
 559         { "glScaled", (GLvoid *) glScaled, _gloffset_Scaled },
 560         { "glScalef", (GLvoid *) glScalef, _gloffset_Scalef },
 561         { "glTranslated", (GLvoid *) glTranslated, _gloffset_Translated },
 562         { "glTranslatef", (GLvoid *) glTranslatef, _gloffset_Translatef },
 563         { "glViewport", (GLvoid *) glViewport, _gloffset_Viewport },
 564         /* 1.1 */
 565         { "glArrayElement", (GLvoid *) glArrayElement, _gloffset_ArrayElement },
 566         { "glColorPointer", (GLvoid *) glColorPointer, _gloffset_ColorPointer },
 567         { "glDisableClientState", (GLvoid *) glDisableClientState, _gloffset_DisableClientState },
 568         { "glDrawArrays", (GLvoid *) glDrawArrays, _gloffset_DrawArrays },
 569         { "glDrawElements", (GLvoid *) glDrawElements, _gloffset_DrawElements },
 570         { "glEdgeFlagPointer", (GLvoid *) glEdgeFlagPointer, _gloffset_EdgeFlagPointer },
 571         { "glEnableClientState", (GLvoid *) glEnableClientState, _gloffset_EnableClientState },
 572         { "glGetPointerv", (GLvoid *) glGetPointerv, _gloffset_GetPointerv },
 573         { "glIndexPointer", (GLvoid *) glIndexPointer, _gloffset_IndexPointer },
 574         { "glInterleavedArrays", (GLvoid *) glInterleavedArrays, _gloffset_InterleavedArrays },
 575         { "glNormalPointer", (GLvoid *) glNormalPointer, _gloffset_NormalPointer },
 576         { "glTexCoordPointer", (GLvoid *) glTexCoordPointer, _gloffset_TexCoordPointer },
 577         { "glVertexPointer", (GLvoid *) glVertexPointer, _gloffset_VertexPointer },
 578         { "glPolygonOffset", (GLvoid *) glPolygonOffset, _gloffset_PolygonOffset },
 579         { "glCopyTexImage1D", (GLvoid *) glCopyTexImage1D, _gloffset_CopyTexImage1D },
 580         { "glCopyTexImage2D", (GLvoid *) glCopyTexImage2D, _gloffset_CopyTexImage2D },
 581         { "glCopyTexSubImage1D", (GLvoid *) glCopyTexSubImage1D, _gloffset_CopyTexSubImage1D },
 582         { "glCopyTexSubImage2D", (GLvoid *) glCopyTexSubImage2D, _gloffset_CopyTexSubImage2D },
 583         { "glTexSubImage1D", (GLvoid *) glTexSubImage1D, _gloffset_TexSubImage1D },
 584         { "glTexSubImage2D", (GLvoid *) glTexSubImage2D, _gloffset_TexSubImage2D },
 585         { "glAreTexturesResident", (GLvoid *) glAreTexturesResident, _gloffset_AreTexturesResident },
 586         { "glBindTexture", (GLvoid *) glBindTexture, _gloffset_BindTexture },
 587         { "glDeleteTextures", (GLvoid *) glDeleteTextures, _gloffset_DeleteTextures },
 588         { "glGenTextures", (GLvoid *) glGenTextures, _gloffset_GenTextures },
 589         { "glIsTexture", (GLvoid *) glIsTexture, _gloffset_IsTexture },
 590         { "glPrioritizeTextures", (GLvoid *) glPrioritizeTextures, _gloffset_PrioritizeTextures },
 591         { "glIndexub", (GLvoid *) glIndexub, _gloffset_Indexub },
 592         { "glIndexubv", (GLvoid *) glIndexubv, _gloffset_Indexubv },
 593         { "glPopClientAttrib", (GLvoid *) glPopClientAttrib, _gloffset_PopClientAttrib },
 594         { "glPushClientAttrib", (GLvoid *) glPushClientAttrib, _gloffset_PushClientAttrib },
 595         /* 1.2 */
 596 #ifdef GL_VERSION_1_2
 597 #define NAME(X) (GLvoid *) X
 598 #else
 599 #define NAME(X) NotImplemented
 600 #endif
 601         { "glBlendColor", (GLvoid *) NAME(glBlendColor), _gloffset_BlendColor },
 602         { "glBlendEquation", (GLvoid *) NAME(glBlendEquation), _gloffset_BlendEquation },
 603         { "glDrawRangeElements", (GLvoid *) NAME(glDrawRangeElements), _gloffset_DrawRangeElements },
 604         { "glColorTable", (GLvoid *) NAME(glColorTable), _gloffset_ColorTable },
 605         { "glColorTableParameterfv", (GLvoid *) NAME(glColorTableParameterfv), _gloffset_ColorTableParameterfv },
 606         { "glColorTableParameteriv", (GLvoid *) NAME(glColorTableParameteriv), _gloffset_ColorTableParameteriv },
 607         { "glCopyColorTable", (GLvoid *) NAME(glCopyColorTable), _gloffset_CopyColorTable },
 608         { "glGetColorTable", (GLvoid *) NAME(glGetColorTable), _gloffset_GetColorTable },
 609         { "glGetColorTableParameterfv", (GLvoid *) NAME(glGetColorTableParameterfv), _gloffset_GetColorTableParameterfv },
 610         { "glGetColorTableParameteriv", (GLvoid *) NAME(glGetColorTableParameteriv), _gloffset_GetColorTableParameteriv },
 611         { "glColorSubTable", (GLvoid *) NAME(glColorSubTable), _gloffset_ColorSubTable },
 612         { "glCopyColorSubTable", (GLvoid *) NAME(glCopyColorSubTable), _gloffset_CopyColorSubTable },
 613         { "glConvolutionFilter1D", (GLvoid *) NAME(glConvolutionFilter1D), _gloffset_ConvolutionFilter1D },
 614         { "glConvolutionFilter2D", (GLvoid *) NAME(glConvolutionFilter2D), _gloffset_ConvolutionFilter2D },
 615         { "glConvolutionParameterf", (GLvoid *) NAME(glConvolutionParameterf), _gloffset_ConvolutionParameterf },
 616         { "glConvolutionParameterfv", (GLvoid *) NAME(glConvolutionParameterfv), _gloffset_ConvolutionParameterfv },
 617         { "glConvolutionParameteri", (GLvoid *) NAME(glConvolutionParameteri), _gloffset_ConvolutionParameteri },
 618         { "glConvolutionParameteriv", (GLvoid *) NAME(glConvolutionParameteriv), _gloffset_ConvolutionParameteriv },
 619         { "glCopyConvolutionFilter1D", (GLvoid *) NAME(glCopyConvolutionFilter1D), _gloffset_CopyConvolutionFilter1D },
 620         { "glCopyConvolutionFilter2D", (GLvoid *) NAME(glCopyConvolutionFilter2D), _gloffset_CopyConvolutionFilter2D },
 621         { "glGetConvolutionFilter", (GLvoid *) NAME(glGetConvolutionFilter), _gloffset_GetConvolutionFilter },
 622         { "glGetConvolutionParameterfv", (GLvoid *) NAME(glGetConvolutionParameterfv), _gloffset_GetConvolutionParameterfv },
 623         { "glGetConvolutionParameteriv", (GLvoid *) NAME(glGetConvolutionParameteriv), _gloffset_GetConvolutionParameteriv },
 624         { "glGetSeparableFilter", (GLvoid *) NAME(glGetSeparableFilter), _gloffset_GetSeparableFilter },
 625         { "glSeparableFilter2D", (GLvoid *) NAME(glSeparableFilter2D), _gloffset_SeparableFilter2D },
 626         { "glGetHistogram", (GLvoid *) NAME(glGetHistogram), _gloffset_GetHistogram },
 627         { "glGetHistogramParameterfv", (GLvoid *) NAME(glGetHistogramParameterfv), _gloffset_GetHistogramParameterfv },
 628         { "glGetHistogramParameteriv", (GLvoid *) NAME(glGetHistogramParameteriv), _gloffset_GetHistogramParameteriv },
 629         { "glGetMinmax", (GLvoid *) NAME(glGetMinmax), _gloffset_GetMinmax },
 630         { "glGetMinmaxParameterfv", (GLvoid *) NAME(glGetMinmaxParameterfv), _gloffset_GetMinmaxParameterfv },
 631         { "glGetMinmaxParameteriv", (GLvoid *) NAME(glGetMinmaxParameteriv), _gloffset_GetMinmaxParameteriv },
 632         { "glHistogram", (GLvoid *) NAME(glHistogram), _gloffset_Histogram },
 633         { "glMinmax", (GLvoid *) NAME(glMinmax), _gloffset_Minmax },
 634         { "glResetHistogram", (GLvoid *) NAME(glResetHistogram), _gloffset_ResetHistogram },
 635         { "glResetMinmax", (GLvoid *) NAME(glResetMinmax), _gloffset_ResetMinmax },
 636         { "glTexImage3D", (GLvoid *) NAME(glTexImage3D), _gloffset_TexImage3D },
 637         { "glTexSubImage3D", (GLvoid *) NAME(glTexSubImage3D), _gloffset_TexSubImage3D },
 638         { "glCopyTexSubImage3D", (GLvoid *) NAME(glCopyTexSubImage3D), _gloffset_CopyTexSubImage3D },
 639 #undef NAME
 640
 641         /* ARB 1. GL_ARB_multitexture */
 642 #ifdef GL_ARB_multitexture
 643 #define NAME(X) (GLvoid *) X
 644 #else
 645 #define NAME(X) NotImplemented
 646 #endif
 647         { "glActiveTextureARB", (GLvoid *) NAME(glActiveTextureARB), _gloffset_ActiveTextureARB },
 648         { "glClientActiveTextureARB", (GLvoid *) NAME(glClientActiveTextureARB), _gloffset_ClientActiveTextureARB },
 649         { "glMultiTexCoord1dARB", (GLvoid *) NAME(glMultiTexCoord1dARB), _gloffset_MultiTexCoord1dARB },
 650         { "glMultiTexCoord1dvARB", (GLvoid *) NAME(glMultiTexCoord1dvARB), _gloffset_MultiTexCoord1dvARB },
 651         { "glMultiTexCoord1fARB", (GLvoid *) NAME(glMultiTexCoord1fARB), _gloffset_MultiTexCoord1fARB },
 652         { "glMultiTexCoord1fvARB", (GLvoid *) NAME(glMultiTexCoord1fvARB), _gloffset_MultiTexCoord1fvARB },
 653         { "glMultiTexCoord1iARB", (GLvoid *) NAME(glMultiTexCoord1iARB), _gloffset_MultiTexCoord1iARB },
 654         { "glMultiTexCoord1ivARB", (GLvoid *) NAME(glMultiTexCoord1ivARB), _gloffset_MultiTexCoord1ivARB },
 655         { "glMultiTexCoord1sARB", (GLvoid *) NAME(glMultiTexCoord1sARB), _gloffset_MultiTexCoord1sARB },
 656         { "glMultiTexCoord1svARB", (GLvoid *) NAME(glMultiTexCoord1svARB), _gloffset_MultiTexCoord1svARB },
 657         { "glMultiTexCoord2dARB", (GLvoid *) NAME(glMultiTexCoord2dARB), _gloffset_MultiTexCoord2dARB },
 658         { "glMultiTexCoord2dvARB", (GLvoid *) NAME(glMultiTexCoord2dvARB), _gloffset_MultiTexCoord2dvARB },
 659         { "glMultiTexCoord2fARB", (GLvoid *) NAME(glMultiTexCoord2fARB), _gloffset_MultiTexCoord2fARB },
 660         { "glMultiTexCoord2fvARB", (GLvoid *) NAME(glMultiTexCoord2fvARB), _gloffset_MultiTexCoord2fvARB },
 661         { "glMultiTexCoord2iARB", (GLvoid *) NAME(glMultiTexCoord2iARB), _gloffset_MultiTexCoord2iARB },
 662         { "glMultiTexCoord2ivARB", (GLvoid *) NAME(glMultiTexCoord2ivARB), _gloffset_MultiTexCoord2ivARB },
 663         { "glMultiTexCoord2sARB", (GLvoid *) NAME(glMultiTexCoord2sARB), _gloffset_MultiTexCoord2sARB },
 664         { "glMultiTexCoord2svARB", (GLvoid *) NAME(glMultiTexCoord2svARB), _gloffset_MultiTexCoord2svARB },
 665         { "glMultiTexCoord3dARB", (GLvoid *) NAME(glMultiTexCoord3dARB), _gloffset_MultiTexCoord3dARB },
 666         { "glMultiTexCoord3dvARB", (GLvoid *) NAME(glMultiTexCoord3dvARB), _gloffset_MultiTexCoord3dvARB },
 667         { "glMultiTexCoord3fARB", (GLvoid *) NAME(glMultiTexCoord3fARB), _gloffset_MultiTexCoord3fARB },
 668         { "glMultiTexCoord3fvARB", (GLvoid *) NAME(glMultiTexCoord3fvARB), _gloffset_MultiTexCoord3fvARB },
 669         { "glMultiTexCoord3iARB", (GLvoid *) NAME(glMultiTexCoord3iARB), _gloffset_MultiTexCoord3iARB },
 670         { "glMultiTexCoord3ivARB", (GLvoid *) NAME(glMultiTexCoord3ivARB), _gloffset_MultiTexCoord3ivARB },
 671         { "glMultiTexCoord3sARB", (GLvoid *) NAME(glMultiTexCoord3sARB), _gloffset_MultiTexCoord3sARB },
 672         { "glMultiTexCoord3svARB", (GLvoid *) NAME(glMultiTexCoord3svARB), _gloffset_MultiTexCoord3svARB },
 673         { "glMultiTexCoord4dARB", (GLvoid *) NAME(glMultiTexCoord4dARB), _gloffset_MultiTexCoord4dARB },
 674         { "glMultiTexCoord4dvARB", (GLvoid *) NAME(glMultiTexCoord4dvARB), _gloffset_MultiTexCoord4dvARB },
 675         { "glMultiTexCoord4fARB", (GLvoid *) NAME(glMultiTexCoord4fARB), _gloffset_MultiTexCoord4fARB },
 676         { "glMultiTexCoord4fvARB", (GLvoid *) NAME(glMultiTexCoord4fvARB), _gloffset_MultiTexCoord4fvARB },
 677         { "glMultiTexCoord4iARB", (GLvoid *) NAME(glMultiTexCoord4iARB), _gloffset_MultiTexCoord4iARB },
 678         { "glMultiTexCoord4ivARB", (GLvoid *) NAME(glMultiTexCoord4ivARB), _gloffset_MultiTexCoord4ivARB },
 679         { "glMultiTexCoord4sARB", (GLvoid *) NAME(glMultiTexCoord4sARB), _gloffset_MultiTexCoord4sARB },
 680         { "glMultiTexCoord4svARB", (GLvoid *) NAME(glMultiTexCoord4svARB), _gloffset_MultiTexCoord4svARB },
 681 #undef NAME
 682
 683         /* ARB 3. GL_ARB_transpose_matrix */
 684 #ifdef GL_ARB_transpose_matrix
 685 #define NAME(X) (GLvoid *) X
 686 #else
 687 #define NAME(X) NotImplemented
 688 #endif
 689         { "glLoadTransposeMatrixdARB", (GLvoid *) NAME(glLoadTransposeMatrixdARB), _gloffset_LoadTransposeMatrixdARB },
 690         { "glLoadTransposeMatrixfARB", (GLvoid *) NAME(glLoadTransposeMatrixfARB), _gloffset_LoadTransposeMatrixfARB },
 691         { "glMultTransposeMatrixdARB", (GLvoid *) NAME(glMultTransposeMatrixdARB), _gloffset_MultTransposeMatrixdARB },
 692         { "glMultTransposeMatrixfARB", (GLvoid *) NAME(glMultTransposeMatrixfARB), _gloffset_MultTransposeMatrixfARB },
 693 #undef NAME
 694
 695         /* ARB 5. GL_ARB_multisample */
 696 #ifdef GL_ARB_multisample
 697 #define NAME(X) (GLvoid *) X
 698 #else
 699 #define NAME(X) (GLvoid *) NotImplemented
 700 #endif
 701         { "glSamplePassARB", NAME(glSamplePassARB), _gloffset_SamplePassARB },
 702         { "glSampleCoverageARB", NAME(glSampleCoverageARB), _gloffset_SampleCoverageARB },
 703 #undef NAME
 704
 705         /* ARB 12. GL_ARB_texture_compression */
 706 #if 000
 707 #if defined(GL_ARB_texture_compression) && defined(_gloffset_CompressedTexImage3DARB)
 708 #define NAME(X) (GLvoid *) X
 709 #else
 710 #define NAME(X) (GLvoid *) NotImplemented
 711 #endif
 712         { "glCompressedTexImage3DARB", NAME(glCompressedTexImage3DARB), _gloffset_CompressedTexImage3DARB },
 713         { "glCompressedTexImage2DARB", NAME(glCompressedTexImage2DARB), _gloffset_CompressedTexImage2DARB },
 714         { "glCompressedTexImage1DARB", NAME(glCompressedTexImage1DARB), _gloffset_CompressedTexImage1DARB },
 715         { "glCompressedTexSubImage3DARB", NAME(glCompressedTexSubImage3DARB), _gloffset_CompressedTexSubImage3DARB },
 716         { "glCompressedTexSubImage2DARB", NAME(glCompressedTexSubImage2DARB), _gloffset_CompressedTexSubImage2DARB },
 717         { "glCompressedTexSubImage1DARB", NAME(glCompressedTexSubImage1DARB), _gloffset_CompressedTexSubImage1DARB },
 718         { "glGetCompressedTexImageARB", NAME(glGetCompressedTexImageARB), _gloffset_GetCompressedTexImageARB },
 719 #undef NAME
 720 #endif
 721
 722         /* 2. GL_EXT_blend_color */
 723 #ifdef GL_EXT_blend_color
 724 #define NAME(X) (GLvoid *) X
 725 #else
 726 #define NAME(X) (GLvoid *) NotImplemented
 727 #endif
 728         { "glBlendColorEXT", NAME(glBlendColorEXT), _gloffset_BlendColor },
 729 #undef NAME
 730
 731         /* 3. GL_EXT_polygon_offset */
 732 #ifdef GL_EXT_polygon_offset
 733 #define NAME(X) (GLvoid *) X
 734 #else
 735 #define NAME(X) (GLvoid *) NotImplemented
 736 #endif
 737         { "glPolygonOffsetEXT", NAME(glPolygonOffsetEXT), _gloffset_PolygonOffsetEXT },
 738 #undef NAME
 739
 740         /* 6. GL_EXT_texture3D */
 741 #ifdef GL_EXT_texture3D
 742 #define NAME(X) (GLvoid *) X
 743 #else
 744 #define NAME(X) (GLvoid *) NotImplemented
 745 #endif
 746         { "glCopyTexSubImage3DEXT", NAME(glCopyTexSubImage3DEXT), _gloffset_CopyTexSubImage3D },
 747         { "glTexImage3DEXT", NAME(glTexImage3DEXT), _gloffset_TexImage3D },
 748         { "glTexSubImage3DEXT", NAME(glTexSubImage3DEXT), _gloffset_TexSubImage3D },
 749 #undef NAME
 750
 751         /* 7. GL_SGI_texture_filter4 */
 752 #ifdef GL_SGI_texture_filter4
 753 #define NAME(X) (GLvoid *) X
 754 #else
 755 #define NAME(X) (GLvoid *) NotImplemented
 756 #endif
 757         { "glGetTexFilterFuncSGIS", NAME(glGetTexFilterFuncSGIS), _gloffset_GetTexFilterFuncSGIS },
 758         { "glTexFilterFuncSGIS", NAME(glTexFilterFuncSGIS), _gloffset_TexFilterFuncSGIS },
 759 #undef NAME
 760
 761         /* 9. GL_EXT_subtexture */
 762 #ifdef GL_EXT_subtexture
 763 #define NAME(X) (GLvoid *) X
 764 #else
 765 #define NAME(X) (GLvoid *) NotImplemented
 766 #endif
 767         { "glTexSubImage1DEXT", NAME(glTexSubImage1DEXT), _gloffset_TexSubImage1D },
 768         { "glTexSubImage2DEXT", NAME(glTexSubImage2DEXT), _gloffset_TexSubImage2D },
 769 #undef NAME
 770
 771         /* 10. GL_EXT_copy_texture */
 772 #ifdef GL_EXT_copy_texture
 773 #define NAME(X) (GLvoid *) X
 774 #else
 775 #define NAME(X) (GLvoid *) NotImplemented
 776 #endif
 777         { "glCopyTexImage1DEXT", NAME(glCopyTexImage1DEXT), _gloffset_CopyTexImage1D },
 778         { "glCopyTexImage2DEXT", NAME(glCopyTexImage2DEXT), _gloffset_CopyTexImage2D },
 779         { "glCopyTexSubImage1DEXT", NAME(glCopyTexSubImage1DEXT), _gloffset_CopyTexSubImage1D },
 780         { "glCopyTexSubImage2DEXT", NAME(glCopyTexSubImage2DEXT), _gloffset_CopyTexSubImage2D },
 781 #undef NAME
 782
 783         /* 11. GL_EXT_histogram */
 784 #ifdef GL_EXT_histogram
 785 #define NAME(X) (GLvoid *) X
 786 #else
 787 #define NAME(X) (GLvoid *) NotImplemented
 788 #endif
 789         { "glGetHistogramEXT", NAME(glGetHistogramEXT), _gloffset_GetHistogramEXT },
 790         { "glGetHistogramParameterfvEXT", NAME(glGetHistogramParameterfvEXT), _gloffset_GetHistogramParameterfvEXT },
 791         { "glGetHistogramParameterivEXT", NAME(glGetHistogramParameterivEXT), _gloffset_GetHistogramParameterivEXT },
 792         { "glGetMinmaxEXT", NAME(glGetMinmaxEXT), _gloffset_GetMinmaxEXT },
 793         { "glGetMinmaxParameterfvEXT", NAME(glGetMinmaxParameterfvEXT), _gloffset_GetMinmaxParameterfvEXT },
 794         { "glGetMinmaxParameterivEXT", NAME(glGetMinmaxParameterivEXT), _gloffset_GetMinmaxParameterivEXT },
 795         { "glHistogramEXT", NAME(glHistogramEXT), _gloffset_Histogram },
 796         { "glMinmaxEXT", NAME(glMinmaxEXT), _gloffset_Minmax },
 797         { "glResetHistogramEXT", NAME(glResetHistogramEXT), _gloffset_ResetHistogram },
 798         { "glResetMinmaxEXT", NAME(glResetMinmaxEXT), _gloffset_ResetMinmax },
 799 #undef NAME
 800
 801         /* 12. GL_EXT_convolution */
 802 #ifdef GL_EXT_convolution
 803 #define NAME(X) (GLvoid *) X
 804 #else
 805 #define NAME(X) (GLvoid *) NotImplemented
 806 #endif
 807         { "glConvolutionFilter1DEXT", NAME(glConvolutionFilter1DEXT), _gloffset_ConvolutionFilter1D },
 808         { "glConvolutionFilter2DEXT", NAME(glConvolutionFilter2DEXT), _gloffset_ConvolutionFilter2D },
 809         { "glConvolutionParameterfEXT", NAME(glConvolutionParameterfEXT), _gloffset_ConvolutionParameterf },
 810         { "glConvolutionParameterfvEXT", NAME(glConvolutionParameterfvEXT), _gloffset_ConvolutionParameterfv },
 811         { "glConvolutionParameteriEXT", NAME(glConvolutionParameteriEXT), _gloffset_ConvolutionParameteri },
 812         { "glConvolutionParameterivEXT", NAME(glConvolutionParameterivEXT), _gloffset_ConvolutionParameteriv },
 813         { "glCopyConvolutionFilter1DEXT", NAME(glCopyConvolutionFilter1DEXT), _gloffset_CopyConvolutionFilter1D },
 814         { "glCopyConvolutionFilter2DEXT", NAME(glCopyConvolutionFilter2DEXT), _gloffset_CopyConvolutionFilter2D },
 815         { "glGetConvolutionFilterEXT", NAME(glGetConvolutionFilterEXT), _gloffset_GetConvolutionFilterEXT },
 816         { "glGetConvolutionParameterivEXT", NAME(glGetConvolutionParameterivEXT), _gloffset_GetConvolutionParameterivEXT },
 817         { "glGetConvolutionParameterfvEXT", NAME(glGetConvolutionParameterfvEXT), _gloffset_GetConvolutionParameterfvEXT },
 818         { "glGetSeparableFilterEXT", NAME(glGetSeparableFilterEXT), _gloffset_GetSeparableFilterEXT },
 819         { "glSeparableFilter2DEXT", NAME(glSeparableFilter2DEXT), _gloffset_SeparableFilter2D },
 820 #undef NAME
 821
 822         /* 14. GL_SGI_color_table */
 823 #ifdef GL_SGI_color_table
 824 #define NAME(X) (GLvoid *) X
 825 #else
 826 #define NAME(X) (GLvoid *) NotImplemented
 827 #endif
 828         { "glColorTableSGI", NAME(glColorTableSGI), _gloffset_ColorTable },
 829         { "glColorTableParameterfvSGI", NAME(glColorTableParameterfvSGI), _gloffset_ColorTableParameterfv },
 830         { "glColorTableParameterivSGI", NAME(glColorTableParameterivSGI), _gloffset_ColorTableParameteriv },
 831         { "glCopyColorTableSGI", NAME(glCopyColorTableSGI), _gloffset_CopyColorTable },
 832         { "glGetColorTableSGI", NAME(glGetColorTableSGI), _gloffset_GetColorTableSGI },
 833         { "glGetColorTableParameterfvSGI", NAME(glGetColorTableParameterfvSGI), _gloffset_GetColorTableParameterfvSGI },
 834         { "glGetColorTableParameterivSGI", NAME(glGetColorTableParameterivSGI), _gloffset_GetColorTableParameterivSGI },
 835 #undef NAME
 836
 837         /* 15. GL_SGIS_pixel_texture */
 838 #ifdef GL_SGIS_pixel_texture
 839 #define NAME(X) (GLvoid *) X
 840 #else
 841 #define NAME(X) (GLvoid *) NotImplemented
 842 #endif
 843         { "glPixelTexGenParameterfSGIS", NAME(glPixelTexGenParameterfSGIS), _gloffset_PixelTexGenParameterfSGIS },
 844         { "glPixelTexGenParameteriSGIS", NAME(glPixelTexGenParameteriSGIS), _gloffset_PixelTexGenParameteriSGIS },
 845         { "glGetPixelTexGenParameterfvSGIS", NAME(glGetPixelTexGenParameterfvSGIS), _gloffset_GetPixelTexGenParameterfvSGIS },
 846         { "glGetPixelTexGenParameterivSGIS", NAME(glGetPixelTexGenParameterivSGIS), _gloffset_GetPixelTexGenParameterivSGIS },
 847 #undef NAME
 848
 849         /* 16. GL_SGIS_texture4D */
 850 #ifdef  GL_SGIS_texture4D
 851 #define NAME(X) (GLvoid *) X
 852 #else
 853 #define NAME(X) (GLvoid *) NotImplemented
 854 #endif
 855         { "glTexImage4DSGIS", NAME(glTexImage4DSGIS), _gloffset_TexImage4DSGIS },
 856         { "glTexSubImage4DSGIS", NAME(glTexSubImage4DSGIS), _gloffset_TexSubImage4DSGIS },
 857 #undef NAME
 858
 859         /* 20. GL_EXT_texture_object */
 860 #ifdef GL_EXT_texture_object
 861 #define NAME(X) (GLvoid *) X
 862 #else
 863 #define NAME(X) (GLvoid *) NotImplemented
 864 #endif
 865         { "glAreTexturesResidentEXT", NAME(glAreTexturesResidentEXT), _gloffset_AreTexturesResidentEXT },
 866         { "glBindTextureEXT", NAME(glBindTextureEXT), _gloffset_BindTexture },
 867         { "glDeleteTexturesEXT", NAME(glDeleteTexturesEXT), _gloffset_DeleteTextures },
 868         { "glGenTexturesEXT", NAME(glGenTexturesEXT), _gloffset_GenTexturesEXT },
 869         { "glIsTextureEXT", NAME(glIsTextureEXT), _gloffset_IsTextureEXT },
 870         { "glPrioritizeTexturesEXT", NAME(glPrioritizeTexturesEXT), _gloffset_PrioritizeTextures },
 871 #undef NAME
 872
 873         /* 21. GL_SGIS_detail_texture */
 874 #ifdef GL_SGIS_detail_texture
 875 #define NAME(X) (GLvoid *) X
 876 #else
 877 #define NAME(X) (GLvoid *) NotImplemented
 878 #endif
 879         { "glDetailTexFuncSGIS", NAME(glDetailTexFuncSGIS), _gloffset_DetailTexFuncSGIS },
 880         { "glGetDetailTexFuncSGIS", NAME(glGetDetailTexFuncSGIS), _gloffset_GetDetailTexFuncSGIS },
 881 #undef NAME
 882
 883         /* 22. GL_SGIS_sharpen_texture */
 884 #ifdef GL_SGIS_sharpen_texture
 885 #define NAME(X) (GLvoid *) X
 886 #else
 887 #define NAME(X) (GLvoid *) NotImplemented
 888 #endif
 889         { "glGetSharpenTexFuncSGIS", NAME(glGetSharpenTexFuncSGIS), _gloffset_GetSharpenTexFuncSGIS },
 890         { "glSharpenTexFuncSGIS", NAME(glSharpenTexFuncSGIS), _gloffset_SharpenTexFuncSGIS },
 891 #undef NAME
 892
 893         /* 25. GL_SGIS_multisample */
 894 #ifdef GL_SGIS_multisample
 895 #define NAME(X) (GLvoid *) X
 896 #else
 897 #define NAME(X) (GLvoid *) NotImplemented
 898 #endif
 899         { "glSampleMaskSGIS", NAME(glSampleMaskSGIS), _gloffset_SampleMaskSGIS },
 900         { "glSamplePatternSGIS", NAME(glSamplePatternSGIS), _gloffset_SamplePatternSGIS },
 901 #undef NAME
 902
 903         /* 30. GL_EXT_vertex_array */
 904 #ifdef GL_EXT_vertex_array
 905 #define NAME(X) (GLvoid *) X
 906 #else
 907 #define NAME(X) (GLvoid *) NotImplemented
 908 #endif
 909         { "glArrayElementEXT", NAME(glArrayElementEXT), _gloffset_ArrayElement },
 910         { "glColorPointerEXT", NAME(glColorPointerEXT), _gloffset_ColorPointerEXT },
 911         { "glDrawArraysEXT", NAME(glDrawArraysEXT), _gloffset_DrawArrays },
 912         { "glEdgeFlagPointerEXT", NAME(glEdgeFlagPointerEXT), _gloffset_EdgeFlagPointerEXT },
 913         { "glGetPointervEXT", NAME(glGetPointervEXT), _gloffset_GetPointerv },
 914         { "glIndexPointerEXT", NAME(glIndexPointerEXT), _gloffset_IndexPointerEXT },
 915         { "glNormalPointerEXT", NAME(glNormalPointerEXT), _gloffset_NormalPointerEXT },
 916         { "glTexCoordPointerEXT", NAME(glTexCoordPointerEXT), _gloffset_TexCoordPointerEXT },
 917         { "glVertexPointerEXT", NAME(glVertexPointerEXT), _gloffset_VertexPointerEXT },
 918 #undef NAME
 919
 920         /* 37. GL_EXT_blend_minmax */
 921 #ifdef GL_EXT_blend_minmax
 922 #define NAME(X) (GLvoid *) X
 923 #else
 924 #define NAME(X) (GLvoid *) NotImplemented
 925 #endif
 926         { "glBlendEquationEXT", NAME(glBlendEquationEXT), _gloffset_BlendEquation },
 927 #undef NAME
 928
 929         /* 52. GL_SGIX_sprite */
 930 #ifdef GL_SGIX_sprite
 931 #define NAME(X) (GLvoid *) X
 932 #else
 933 #define NAME(X) (GLvoid *) NotImplemented
 934 #endif
 935         { "glSpriteParameterfSGIX", NAME(glSpriteParameterfSGIX), _gloffset_SpriteParameterfSGIX },
 936         { "glSpriteParameterfvSGIX", NAME(glSpriteParameterfvSGIX), _gloffset_SpriteParameterfvSGIX },
 937         { "glSpriteParameteriSGIX", NAME(glSpriteParameteriSGIX), _gloffset_SpriteParameteriSGIX },
 938         { "glSpriteParameterivSGIX", NAME(glSpriteParameterivSGIX), _gloffset_SpriteParameterivSGIX },
 939 #undef NAME
 940
 941         /* 54. GL_EXT_point_parameters */
 942 #ifdef GL_EXT_point_parameters
 943 #define NAME(X) (GLvoid *) X
 944 #else
 945 #define NAME(X) (GLvoid *) NotImplemented
 946 #endif
 947         { "glPointParameterfEXT", NAME(glPointParameterfEXT), _gloffset_PointParameterfEXT },
 948         { "glPointParameterfvEXT", NAME(glPointParameterfvEXT), _gloffset_PointParameterfvEXT },
 949         { "glPointParameterfSGIS", NAME(glPointParameterfSGIS), _gloffset_PointParameterfEXT },
 950         { "glPointParameterfvSGIS", NAME(glPointParameterfvSGIS), _gloffset_PointParameterfvEXT },
 951 #undef NAME
 952
 953         /* 55. GL_SGIX_instruments */
 954 #ifdef GL_SGIX_instruments
 955 #define NAME(X) (GLvoid *) X
 956 #else
 957 #define NAME(X) (GLvoid *) NotImplemented
 958 #endif
 959         { "glInstrumentsBufferSGIX", NAME(glInstrumentsBufferSGIX), _gloffset_InstrumentsBufferSGIX },
 960         { "glStartInstrumentsSGIX", NAME(glStartInstrumentsSGIX), _gloffset_StartInstrumentsSGIX },
 961         { "glStopInstrumentsSGIX", NAME(glStopInstrumentsSGIX), _gloffset_StopInstrumentsSGIX },
 962         { "glReadInstrumentsSGIX", NAME(glReadInstrumentsSGIX), _gloffset_ReadInstrumentsSGIX },
 963         { "glPollInstrumentsSGIX", NAME(glPollInstrumentsSGIX), _gloffset_PollInstrumentsSGIX },
 964         { "glGetInstrumentsSGIX", NAME(glGetInstrumentsSGIX), _gloffset_GetInstrumentsSGIX },
 965 #undef NAME
 966
 967         /* 57. GL_SGIX_framezoom */
 968 #ifdef GL_SGIX_framezoom
 969 #define NAME(X) (GLvoid *) X
 970 #else
 971 #define NAME(X) (GLvoid *) NotImplemented
 972 #endif
 973         { "glFrameZoomSGIX", NAME(glFrameZoomSGIX), _gloffset_FrameZoomSGIX },
 974 #undef NAME
 975
 976         /* 58. GL_SGIX_tag_sample_buffer */
 977 #ifdef GL_SGIX_tag_sample_buffer
 978 #define NAME(X) (GLvoid *) X
 979 #else
 980 #define NAME(X) (GLvoid *) NotImplemented
 981 #endif
 982         { "glTagSampleBufferSGIX", NAME(glTagSampleBufferSGIX), _gloffset_TagSampleBufferSGIX },
 983 #undef NAME
 984
 985         /* 60. GL_SGIX_reference_plane */
 986 #ifdef GL_SGIX_reference_plane
 987 #define NAME(X) (GLvoid *) X
 988 #else
 989 #define NAME(X) (GLvoid *) NotImplemented
 990 #endif
 991         { "glReferencePlaneSGIX", NAME(glReferencePlaneSGIX), _gloffset_ReferencePlaneSGIX },
 992 #undef NAME
 993
 994         /* 61. GL_SGIX_flush_raster */
 995 #ifdef GL_SGIX_flush_raster
 996 #define NAME(X) (GLvoid *) X
 997 #else
 998 #define NAME(X) (GLvoid *) NotImplemented
 999 #endif
1000         { "glFlushRasterSGIX", NAME(glFlushRasterSGIX), _gloffset_FlushRasterSGIX },
1001 #undef NAME
1002
1003         /* 66. GL_HP_image_transform */
1004 #if 0
1005 #ifdef GL_HP_image_transform
1006 #define NAME(X) (GLvoid *) X
1007 #else
1008 #define NAME(X) (GLvoid *) NotImplemented
1009 #endif
1010         { "glGetImageTransformParameterfvHP", NAME(glGetImageTransformParameterfvHP), _gloffset_GetImageTransformParameterfvHP },
1011         { "glGetImageTransformParameterivHP", NAME(glGetImageTransformParameterivHP), _gloffset_GetImageTransformParameterivHP },
1012         { "glImageTransformParameterfHP", NAME(glImageTransformParameterfHP), _gloffset_ImageTransformParameterfHP },
1013         { "glImageTransformParameterfvHP", NAME(glImageTransformParameterfvHP), _gloffset_ImageTransformParameterfvHP },
1014         { "glImageTransformParameteriHP", NAME(glImageTransformParameteriHP), _gloffset_ImageTransformParameteriHP },
1015         { "glImageTransformParameterivHP", NAME(glImageTransformParameterivHP), _gloffset_ImageTransformParameterivHP },
1016 #undef NAME
1017 #endif
1018
1019         /* 74. GL_EXT_color_subtable */
1020 #ifdef GL_EXT_color_subtable
1021 #define NAME(X) (GLvoid *) X
1022 #else
1023 #define NAME(X) (GLvoid *) NotImplemented
1024 #endif
1025         { "glColorSubTableEXT", NAME(glColorSubTableEXT), _gloffset_ColorSubTable },
1026         { "glCopyColorSubTableEXT", NAME(glCopyColorSubTableEXT), _gloffset_CopyColorSubTable },
1027 #undef NAME
1028
1029         /* 77. GL_PGI_misc_hints */
1030 #ifdef GL_PGI_misc_hints
1031 #define NAME(X) (GLvoid *) X
1032 #else
1033 #define NAME(X) (GLvoid *) NotImplemented
1034 #endif
1035         { "glHintPGI", NAME(glHintPGI), _gloffset_HintPGI },
1036 #undef NAME
1037
1038         /* 78. GL_EXT_paletted_texture */
1039 #ifdef GL_EXT_paletted_texture
1040 #define NAME(X) (GLvoid *) X
1041 #else
1042 #define NAME(X) (GLvoid *) NotImplemented
1043 #endif
1044         { "glColorTableEXT", NAME(glColorTableEXT), _gloffset_ColorTable },
1045         { "glGetColorTableEXT", NAME(glGetColorTableEXT), _gloffset_GetColorTable },
1046         { "glGetColorTableParameterfvEXT", NAME(glGetColorTableParameterfvEXT), _gloffset_GetColorTableParameterfv },
1047         { "glGetColorTableParameterivEXT", NAME(glGetColorTableParameterivEXT), _gloffset_GetColorTableParameteriv },
1048 #undef NAME
1049
1050         /* 80. GL_SGIX_list_priority */
1051 #ifdef GL_SGIX_list_priority
1052 #define NAME(X) (GLvoid *) X
1053 #else
1054 #define NAME(X) (GLvoid *) NotImplemented
1055 #endif
1056         { "glGetListParameterfvSGIX", NAME(glGetListParameterfvSGIX), _gloffset_GetListParameterfvSGIX },
1057         { "glGetListParameterivSGIX", NAME(glGetListParameterivSGIX), _gloffset_GetListParameterivSGIX },
1058         { "glListParameterfSGIX", NAME(glListParameterfSGIX), _gloffset_ListParameterfSGIX },
1059         { "glListParameterfvSGIX", NAME(glListParameterfvSGIX), _gloffset_ListParameterfvSGIX },
1060         { "glListParameteriSGIX", NAME(glListParameteriSGIX), _gloffset_ListParameteriSGIX },
1061         { "glListParameterivSGIX", NAME(glListParameterivSGIX), _gloffset_ListParameterivSGIX },
1062 #undef NAME
1063
1064         /* 94. GL_EXT_index_material */
1065 #ifdef GL_EXT_index_material
1066 #define NAME(X) (GLvoid *) X
1067 #else
1068 #define NAME(X) (GLvoid *) NotImplemented
1069 #endif
1070         { "glIndexMaterialEXT", NAME(glIndexMaterialEXT), _gloffset_IndexMaterialEXT },
1071 #undef NAME
1072
1073         /* 95. GL_EXT_index_func */
1074 #ifdef GL_EXT_index_func
1075 #define NAME(X) (GLvoid *) X
1076 #else
1077 #define NAME(X) (GLvoid *) NotImplemented
1078 #endif
1079         { "glIndexFuncEXT", NAME(glIndexFuncEXT), _gloffset_IndexFuncEXT },
1080 #undef NAME
1081
1082         /* 97. GL_EXT_compiled_vertex_array */
1083 #ifdef GL_EXT_compiled_vertex_array
1084 #define NAME(X) (GLvoid *) X
1085 #else
1086 #define NAME(X) (GLvoid *) NotImplemented
1087 #endif
1088         { "glLockArraysEXT", NAME(glLockArraysEXT), _gloffset_LockArraysEXT },
1089         { "glUnlockArraysEXT", NAME(glUnlockArraysEXT), _gloffset_UnlockArraysEXT },
1090 #undef NAME
1091
1092         /* 98. GL_EXT_cull_vertex */
1093 #ifdef GL_EXT_cull_vertex
1094 #define NAME(X) (GLvoid *) X
1095 #else
1096 #define NAME(X) (GLvoid *) NotImplemented
1097 #endif
1098         { "glCullParameterfvEXT", NAME(glCullParameterfvEXT), _gloffset_CullParameterfvEXT },
1099         { "glCullParameterdvEXT", NAME(glCullParameterdvEXT), _gloffset_CullParameterdvEXT },
1100 #undef NAME
1101
1102         /* 102. GL_SGIX_fragment_lighting */
1103 #ifdef GL_SGIX_fragment_lighting
1104 #define NAME(X) (GLvoid *) X
1105 #else
1106 #define NAME(X) (GLvoid *) NotImplemented
1107 #endif
1108         { "glFragmentColorMaterialSGIX", NAME(glFragmentColorMaterialSGIX), _gloffset_FragmentColorMaterialSGIX },
1109         { "glFragmentLightfSGIX", NAME(glFragmentLightfSGIX), _gloffset_FragmentLightfSGIX },
1110         { "glFragmentLightfvSGIX", NAME(glFragmentLightfvSGIX), _gloffset_FragmentLightfvSGIX },
1111         { "glFragmentLightiSGIX", NAME(glFragmentLightiSGIX), _gloffset_FragmentLightiSGIX },
1112         { "glFragmentLightivSGIX", NAME(glFragmentLightivSGIX), _gloffset_FragmentLightivSGIX },
1113         { "glFragmentLightModelfSGIX", NAME(glFragmentLightModelfSGIX), _gloffset_FragmentLightModelfSGIX },
1114         { "glFragmentLightModelfvSGIX", NAME(glFragmentLightModelfvSGIX), _gloffset_FragmentLightModelfvSGIX },
1115         { "glFragmentLightModeliSGIX", NAME(glFragmentLightModeliSGIX), _gloffset_FragmentLightModeliSGIX },
1116         { "glFragmentLightModelivSGIX", NAME(glFragmentLightModelivSGIX), _gloffset_FragmentLightModelivSGIX },
1117         { "glFragmentMaterialfSGIX", NAME(glFragmentMaterialfSGIX), _gloffset_FragmentMaterialfSGIX },
1118         { "glFragmentMaterialfvSGIX", NAME(glFragmentMaterialfvSGIX), _gloffset_FragmentMaterialfvSGIX },
1119         { "glFragmentMaterialiSGIX", NAME(glFragmentMaterialiSGIX), _gloffset_FragmentMaterialiSGIX },
1120         { "glFragmentMaterialivSGIX", NAME(glFragmentMaterialivSGIX), _gloffset_FragmentMaterialivSGIX },
1121         { "glGetFragmentLightfvSGIX", NAME(glGetFragmentLightfvSGIX), _gloffset_GetFragmentLightfvSGIX },
1122         { "glGetFragmentLightivSGIX", NAME(glGetFragmentLightivSGIX), _gloffset_GetFragmentLightivSGIX },
1123         { "glGetFragmentMaterialfvSGIX", NAME(glGetFragmentMaterialfvSGIX), _gloffset_GetFragmentMaterialfvSGIX },
1124         { "glGetFragmentMaterialivSGIX", NAME(glGetFragmentMaterialivSGIX), _gloffset_GetFragmentMaterialivSGIX },
1125         { "glLightEnviSGIX", NAME(glLightEnviSGIX), _gloffset_LightEnviSGIX },
1126 #undef NAME
1127
1128         /* 112. GL_EXT_draw_range_elements */
1129 #if 000
1130 #ifdef GL_EXT_draw_range_elements
1131 #define NAME(X) (GLvoid *) X
1132 #else
1133 #define NAME(X) (GLvoid *) NotImplemented
1134 #endif
1135         { "glDrawRangeElementsEXT", NAME(glDrawRangeElementsEXT), _gloffset_DrawRangeElementsEXT },
1136 #undef NAME
1137 #endif
1138
1139         /* 117. GL_EXT_light_texture */
1140 #if 000
1141 #ifdef GL_EXT_light_texture
1142 #define NAME(X) (GLvoid *) X
1143 #else
1144 #define NAME(X) (GLvoid *) NotImplemented
1145 #endif
1146         { "glApplyTextureEXT", NAME(glApplyTextureEXT), _gloffset_ApplyTextureEXT },
1147         { "glTextureLightEXT", NAME(glTextureLightEXT), _gloffset_TextureLightEXT },
1148         { "glTextureMaterialEXT", NAME(glTextureMaterialEXT), _gloffset_TextureMaterialEXT },
1149 #undef NAME
1150
1151         /* 135. GL_INTEL_texture_scissor */
1152 #ifdef GL_INTEL_texture_scissor
1153 #define NAME(X) (GLvoid *) X
1154 #else
1155 #define NAME(X) (GLvoid *) NotImplemented
1156 #endif
1157         { "glTexScissorINTEL", NAME(glTexScissorINTEL), _gloffset_TexScissorINTEL },
1158         { "glTexScissorFuncINTEL", NAME(glTexScissorFuncINTEL), _gloffset_glTexScissorFuncINTEL },
1159 #undef NAME
1160
1161         /* 136. GL_INTEL_parallel_arrays */
1162 #ifdef GL_INTEL_parallel_arrays
1163 #define NAME(X) (GLvoid *) X
1164 #else
1165 #define NAME(X) (GLvoid *) NotImplemented
1166 #endif
1167         { "glVertexPointervINTEL", NAME(glVertexPointervINTEL), _gloffset_VertexPointervINTEL },
1168         { "glNormalPointervINTEL", NAME(glNormalPointervINTEL), _gloffset_NormalPointervINTEL },
1169         { "glColorPointervINTEL", NAME(glColorPointervINTEL), _gloffset_ColorPointervINTEL },
1170         { "glTexCoordPointervINTEL", NAME(glTexCoordPointervINTEL), _gloffset_glxCoordPointervINTEL },
1171 #undef NAME
1172 #endif
1173
1174         /* 138. GL_EXT_pixel_transform */
1175 #if 000
1176 #ifdef GL_EXT_pixel_transform
1177 #define NAME(X) (GLvoid *) X
1178 #else
1179 #define NAME(X) (GLvoid *) NotImplemented
1180 #endif
1181         { "glPixelTransformParameteriEXT", NAME(glPixelTransformParameteriEXT), _gloffset_PixelTransformParameteriEXT },
1182         { "glPixelTransformParameterfEXT", NAME(glPixelTransformParameterfEXT), _gloffset_PixelTransformParameterfEXT },
1183         { "glPixelTransformParameterivEXT", NAME(glPixelTransformParameterivEXT), _gloffset_PixelTransformParameterivEXT },
1184         { "glPixelTransformParameterfvEXT", NAME(glPixelTransformParameterfvEXT), _gloffset_PixelTransformParameterfvEXT },
1185         { "glGetPixelTransformParameterivEXT", NAME(glGetPixelTransformParameterivEXT), _gloffset_GetPixelTransformParameterivEXT },
1186         { "glGetPixelTransformParameterfvEXT", NAME(glGetPixelTransformParameterfvEXT), _gloffset_GetPixelTransformParameterfvEXT },
1187 #undef NAME
1188
1189         /* 145. GL_EXT_secondary_color */
1190 #ifdef GL_EXT_secondary_color
1191 #define NAME(X) (GLvoid *) X
1192 #else
1193 #define NAME(X) (GLvoid *) NotImplemented
1194 #endif
1195         { "glSecondaryColor3bEXT", NAME(glSecondaryColor3bEXT), _gloffset_SecondaryColor3bEXT },
1196         { "glSecondaryColor3dEXT", NAME(glSecondaryColor3dEXT), _gloffset_SecondaryColor3dEXT },
1197         { "glSecondaryColor3fEXT", NAME(glSecondaryColor3fEXT), _gloffset_SecondaryColor3fEXT },
1198         { "glSecondaryColor3iEXT", NAME(glSecondaryColor3iEXT), _gloffset_SecondaryColor3iEXT },
1199         { "glSecondaryColor3sEXT", NAME(glSecondaryColor3sEXT), _gloffset_SecondaryColor3sEXT },
1200         { "glSecondaryColor3ubEXT", NAME(glSecondaryColor3ubEXT), _gloffset_SecondaryColor3ubEXT },
1201         { "glSecondaryColor3uiEXT", NAME(glSecondaryColor3uiEXT), _gloffset_SecondaryColor3uiEXT },
1202         { "glSecondaryColor3usEXT", NAME(glSecondaryColor3usEXT), _gloffset_SecondaryColor3usEXT },
1203         { "glSecondaryColor4bEXT", NAME(glSecondaryColor4bEXT), _gloffset_SecondaryColor4bEXT },
1204         { "glSecondaryColor4dEXT", NAME(glSecondaryColor4dEXT), _gloffset_SecondaryColor4dEXT },
1205         { "glSecondaryColor4fEXT", NAME(glSecondaryColor4fEXT), _gloffset_SecondaryColor4fEXT },
1206         { "glSecondaryColor4iEXT", NAME(glSecondaryColor4iEXT), _gloffset_SecondaryColor4iEXT },
1207         { "glSecondaryColor4sEXT", NAME(glSecondaryColor4sEXT), _gloffset_SecondaryColor4sEXT },
1208         { "glSecondaryColor4ubEXT", NAME(glSecondaryColor4ubEXT), _gloffset_SecondaryColor4ubEXT },
1209         { "glSecondaryColor4uiEXT", NAME(glSecondaryColor4uiEXT), _gloffset_SecondaryColor4uiEXT },
1210         { "glSecondaryColor4usEXT", NAME(glSecondaryColor4usEXT), _gloffset_SecondaryColor4usEXT },
1211         { "glSecondaryColor3bvEXT", NAME(glSecondaryColor3bvEXT), _gloffset_SecondaryColor3bvEXT },
1212         { "glSecondaryColor3dvEXT", NAME(glSecondaryColor3dvEXT), _gloffset_SecondaryColor3dvEXT },
1213         { "glSecondaryColor3fvEXT", NAME(glSecondaryColor3fvEXT), _gloffset_SecondaryColor3fvEXT },
1214         { "glSecondaryColor3ivEXT", NAME(glSecondaryColor3ivEXT), _gloffset_SecondaryColor3ivEXT },
1215         { "glSecondaryColor3svEXT", NAME(glSecondaryColor3svEXT), _gloffset_SecondaryColor3svEXT },
1216         { "glSecondaryColor3ubvEXT", NAME(glSecondaryColor3ubvEXT), _gloffset_SecondaryColor3ubvEXT },
1217         { "glSecondaryColor3uivEXT", NAME(glSecondaryColor3uivEXT), _gloffset_SecondaryColor3uivEXT },
1218         { "glSecondaryColor3usvEXT", NAME(glSecondaryColor3usvEXT), _gloffset_SecondaryColor3usvEXT },
1219         { "glSecondaryColor4bvEXT", NAME(glSecondaryColor4bvEXT), _gloffset_SecondaryColor4bvEXT },
1220         { "glSecondaryColor4dvEXT", NAME(glSecondaryColor4dvEXT), _gloffset_SecondaryColor4dvEXT },
1221         { "glSecondaryColor4fvEXT", NAME(glSecondaryColor4fvEXT), _gloffset_SecondaryColor4fvEXT },
1222         { "glSecondaryColor4ivEXT", NAME(glSecondaryColor4ivEXT), _gloffset_SecondaryColor4ivEXT },
1223         { "glSecondaryColor4svEXT", NAME(glSecondaryColor4svEXT), _gloffset_SecondaryColor4svEXT },
1224         { "glSecondaryColor4ubvEXT", NAME(glSecondaryColor4ubvEXT), _gloffset_SecondaryColor4ubvEXT },
1225         { "glSecondaryColor4uivEXT", NAME(glSecondaryColor4uivEXT), _gloffset_SecondaryColor4uivEXT },
1226         { "glSecondaryColor4usvEXT", NAME(glSecondaryColor4usvEXT), _gloffset_SecondaryColor4usvEXT },
1227         { "glSecondaryColorPointerEXT", NAME(glSecondaryColorPointerEXT), _gloffset_SecondaryColorPointerEXT },
1228 #undef NAME
1229
1230         /* 147. GL_EXT_texture_perturb_normal */
1231 #ifdef GL_EXT_texture_perturb_normal
1232 #define NAME(X) (GLvoid *) X
1233 #else
1234 #define NAME(X) (GLvoid *) NotImplemented
1235 #endif
1236         { "glTextureNormalEXT", NAME(glTextureNormalEXT), _gloffset_TextureNormalEXT },
1237 #undef NAME
1238
1239         /* 148. GL_EXT_multi_draw_arrays */
1240 #ifdef GL_EXT_multi_draw_arrays
1241 #define NAME(X) (GLvoid *) X
1242 #else
1243 #define NAME(X) (GLvoid *) NotImplemented
1244 #endif
1245         { "glMultiDrawArraysEXT", NAME(glMultiDrawArraysEXT), _gloffset_MultiDrawArraysEXT },
1246 #undef NAME
1247 #endif
1248
1249         /* 149. GL_EXT_fog_coord */
1250 #ifdef GL_EXT_fog_coord
1251 #define NAME(X) (GLvoid *) X
1252 #else
1253 #define NAME(X) (GLvoid *) NotImplemented
1254 #endif
1255         { "glFogCoordfEXT", NAME(glFogCoordfEXT), _gloffset_FogCoordfEXT },
1256         { "glFogCoordfvEXT", NAME(glFogCoordfvEXT), _gloffset_FogCoordfvEXT },
1257         { "glFogCoorddEXT", NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT },
1258         { "glFogCoorddEXT", NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT },
1259         { "glFogCoordPointerEXT", NAME(glFogCoordPointerEXT), _gloffset_FogCoordPointerEXT },
1260 #undef NAME
1261
1262 #if 000
1263         /* 156. GL_EXT_coordinate_frame */
1264 #ifdef GL_EXT_coordinate_frame
1265 #define NAME(X) (GLvoid *) X
1266 #else
1267 #define NAME(X) (GLvoid *) NotImplemented
1268 #endif
1269         { "glTangent3bEXT", NAME(glTangent3bEXT), _gloffset_Tangent3bEXT },
1270         { "glTangent3dEXT", NAME(glTangent3dEXT), _gloffset_Tangent3dEXT },
1271         { "glTangent3fEXT", NAME(glTangent3fEXT), _gloffset_Tangent3fEXT },
1272         { "glTangent3iEXT", NAME(glTangent3iEXT), _gloffset_Tangent3iEXT },
1273         { "glTangent3sEXT", NAME(glTangent3sEXT), _gloffset_Tangent3sEXT },
1274         { "glTangent3bvEXT", NAME(glTangent3bvEXT), _gloffset_Tangent3bvEXT },
1275         { "glTangent3dvEXT", NAME(glTangent3dvEXT), _gloffset_Tangent3dvEXT },
1276         { "glTangent3fvEXT", NAME(glTangent3fvEXT), _gloffset_Tangent3fvEXT },
1277         { "glTangent3ivEXT", NAME(glTangent3ivEXT), _gloffset_Tangent3ivEXT },
1278         { "glTangent3svEXT", NAME(glTangent3svEXT), _gloffset_Tangent3svEXT },
1279         { "glBinormal3bEXT", NAME(glBinormal3bEXT), _gloffset_Binormal3bEXT },
1280         { "glBinormal3dEXT", NAME(glBinormal3dEXT), _gloffset_Binormal3dEXT },
1281         { "glBinormal3fEXT", NAME(glBinormal3fEXT), _gloffset_Binormal3fEXT },
1282         { "glBinormal3iEXT", NAME(glBinormal3iEXT), _gloffset_Binormal3iEXT },
1283         { "glBinormal3sEXT", NAME(glBinormal3sEXT), _gloffset_Binormal3sEXT },
1284         { "glBinormal3bvEXT", NAME(glBinormal3bvEXT), _gloffset_Binormal3bvEXT },
1285         { "glBinormal3dvEXT", NAME(glBinormal3dvEXT), _gloffset_Binormal3dvEXT },
1286         { "glBinormal3fvEXT", NAME(glBinormal3fvEXT), _gloffset_Binormal3fvEXT },
1287         { "glBinormal3ivEXT", NAME(glBinormal3ivEXT), _gloffset_Binormal3ivEXT },
1288         { "glBinormal3svEXT", NAME(glBinormal3svEXT), _gloffset_Binormal3svEXT },
1289         { "glTangentPointerEXT", NAME(glTangentPointerEXT), _gloffset_TangentPointerEXT },
1290         { "glBinormalPointerEXT", NAME(glBinormalPointerEXT), _gloffset_BinormalPointerEXT },
1291 #undef NAME
1292
1293         /* 164. GL_SUN_global_alpha */
1294 #ifdef GL_SUN_global_alpha
1295 #define NAME(X) (GLvoid *) X
1296 #else
1297 #define NAME(X) (GLvoid *) NotImplemented
1298 #endif
1299         { "glGlobalAlphaFactorbSUN", NAME(glGlobalAlphaFactorbSUN), _gloffset_GlobalAlphaFactorbSUN },
1300         { "glGlobalAlphaFactorsSUN", NAME(glGlobalAlphaFactorsSUN), _gloffset_GlobalAlphaFactorsSUN },
1301         { "glGlobalAlphaFactoriSUN", NAME(glGlobalAlphaFactoriSUN), _gloffset_GlobalAlphaFactoriSUN },
1302         { "glGlobalAlphaFactorfSUN", NAME(glGlobalAlphaFactorfSUN), _gloffset_GlobalAlphaFactorfSUN },
1303         { "glGlobalAlphaFactordSUN", NAME(glGlobalAlphaFactordSUN), _gloffset_GlobalAlphaFactordSUN },
1304         { "glGlobalAlphaFactorubSUN", NAME(glGlobalAlphaFactorubSUN), _gloffset_GlobalAlphaFactorubSUN },
1305         { "glGlobalAlphaFactorusSUN", NAME(glGlobalAlphaFactorusSUN), _gloffset_GlobalAlphaFactorusSUN },
1306         { "glGlobalAlphaFactoruiSUN", NAME(glGlobalAlphaFactoruiSUN), _gloffset_GlobalAlphaFactoruiSUN },
1307 #undef NAME
1308
1309         /* 165. GL_SUN_triangle_list */
1310 #ifdef GL_SUN_triangle_list
1311 #define NAME(X) (GLvoid *) X
1312 #else
1313 #define NAME(X) (GLvoid *) NotImplemented
1314 #endif
1315         { "glReplacementCodeuiSUN", NAME(glReplacementCodeuiSUN), _gloffset_ReplacementCodeuiSUN },
1316         { "glReplacementCodeusSUN", NAME(glReplacementCodeusSUN), _gloffset_ReplacementCodeusSUN },
1317         { "glReplacementCodeubSUN", NAME(glReplacementCodeubSUN), _gloffset_ReplacementCodeubSUN },
1318         { "glReplacementCodeuivSUN", NAME(glReplacementCodeuivSUN), _gloffset_ReplacementCodeuivSUN },
1319         { "glReplacementCodeusvSUN", NAME(glReplacementCodeusvSUN), _gloffset_ReplacementCodeusvSUN },
1320         { "glReplacementCodeubvSUN", NAME(glReplacementCodeubvSUN), _gloffset_ReplacementCodeubvSUN },
1321         { "glReplacementCodePointerSUN", NAME(glReplacementCodePointerSUN), _gloffset_ReplacementCodePointerSUN },
1322 #undef NAME
1323
1324         /* 166. GL_SUN_vertex */
1325 #ifdef GL_SUN_vertex
1326 #define NAME(X) (GLvoid *) X
1327 #else
1328 #define NAME(X) (GLvoid *) NotImplemented
1329 #endif
1330         { "glColor4ubVertex2fSUN", NAME(glColor4ubVertex2fSUN), _gloffset_Color4ubVertex2fSUN },
1331         { "glColor4ubVertex2fvSUN", NAME(glColor4ubVertex2fvSUN), _gloffset_Color4ubVertex2fvSUN },
1332         { "glColor4ubVertex3fSUN", NAME(glColor4ubVertex3fSUN), _gloffset_Color4ubVertex3fSUN },
1333         { "glColor4ubVertex3fvSUN", NAME(glColor4ubVertex3fvSUN), _gloffset_Color4ubVertex3fvSUN },
1334         { "glColor3fVertex3fSUN", NAME(glColor3fVertex3fSUN), _gloffset_Color3fVertex3fSUN },
1335         { "glColor3fVertex3fvSUN", NAME(glColor3fVertex3fvSUN), _gloffset_Color3fVertex3fvSUN },
1336         { "glNormal3fVertex3fSUN", NAME(glNormal3fVertex3fSUN), _gloffset_Normal3fVertex3fSUN },
1337         { "glNormal3fVertex3fvSUN", NAME(glNormal3fVertex3fvSUN), _gloffset_Normal3fVertex3fvSUN },
1338         { "glColor4fNormal3fVertex3fSUN", NAME(glColor4fNormal3fVertex3fSUN), _gloffset_Color4fNormal3fVertex3fSUN },
1339         { "glColor4fNormal3fVertex3fvSUN", NAME(glColor4fNormal3fVertex3fvSUN), _gloffset_Color4fNormal3fVertex3fvSUN },
1340         { "glTexCoord2fVertex3fSUN", NAME(glTexCoord2fVertex3fSUN), _gloffset_TexCoord2fVertex3fSUN },
1341         { "glTexCoord2fVertex3fvSUN", NAME(glTexCoord2fVertex3fvSUN), _gloffset_TexCoord2fVertex3fvSUN },
1342         { "glTexCoord4fVertex4fSUN", NAME(glTexCoord4fVertex4fSUN), _gloffset_TexCoord4fVertex4fSUN },
1343         { "glTexCoord4fVertex4fvSUN", NAME(glTexCoord4fVertex4fvSUN), _gloffset_TexCoord4fVertex4fvSUN },
1344         { "glTexCoord2fColor4ubVertex3fSUN", NAME(glTexCoord2fColor4ubVertex3fSUN), _gloffset_TexCoord2fColor4ubVertex3fSUN },
1345         { "glTexCoord2fColor4ubVertex3fvSUN", NAME(glTexCoord2fColor4ubVertex3fvSUN), _gloffset_TexCoord2fColor4ubVertex3fvSUN },
1346         { "glTexCoord2fColor3fVertex3fSUN", NAME(glTexCoord2fColor3fVertex3fSUN), _gloffset_TexCoord2fColor3fVertex3fSUN },
1347         { "glTexCoord2fColor3fVertex3fvSUN", NAME(glTexCoord2fColor3fVertex3fvSUN), _gloffset_TexCoord2fColor3fVertex3fvSUN },
1348         { "glTexCoord2fNormal3fVertex3fSUN", NAME(glTexCoord2fNormal3fVertex3fSUN), _gloffset_TexCoord2fNormal3fVertex3fSUN },
1349         { "glTexCoord2fNormal3fVertex3fvSUN", NAME(glTexCoord2fNormal3fVertex3fvSUN), _gloffset_TexCoord2fNormal3fVertex3fvSUN },
1350         { "glTexCoord2fColor4fNormal3fVertex3fSUN", NAME(glTexCoord2fColor4fNormal3fVertex3fSUN), _gloffset_TexCoord2fColor4fNormal3fVertex3fSUN },
1351         { "glTexCoord2fColor4fNormal3fVertex3fvSUN", NAME(glTexCoord2fColor4fNormal3fVertex3fvSUN), _gloffset_TexCoord2fColor4fNormal3fVertex3fvSUN },
1352         { "glTexCoord4fColor4fNormal3fVertex4fSUN", NAME(glTexCoord4fColor4fNormal3fVertex4fSUN), _gloffset_TexCoord4fColor4fNormal3fVertex4fSUN },
1353         { "glTexCoord4fColor4fNormal3fVertex4fvSUN", NAME(glTexCoord4fColor4fNormal3fVertex4fvSUN), _gloffset_TexCoord4fColor4fNormal3fVertex4fvSUN },
1354         { "glReplacementCodeuiVertex3fSUN", NAME(glReplacementCodeuiVertex3fSUN), _gloffset_ReplacementCodeuiVertex3fSUN },
1355         { "glReplacementCodeuiVertex3fvSUN", NAME(glReplacementCodeuiVertex3fvSUN), _gloffset_ReplacementCodeuiVertex3fvSUN },
1356         { "glReplacementCodeuiColor4ubVertex3fSUN", NAME(glReplacementCodeuiColor4ubVertex3fSUN), _gloffset_ReplacementCodeuiColor4ubVertex3fSUN },
1357         { "glReplacementCodeuiColor4ubVertex3fvSUN", NAME(glReplacementCodeuiColor4ubVertex3fvSUN), _gloffset_ReplacementCodeuiColor4ubVertex3fvSUN },
1358         { "glReplacementCodeuiColor3fVertex3fSUN", NAME(glReplacementCodeuiColor3fVertex3fSUN), _gloffset_ReplacementCodeuiColor3fVertex3fSUN },
1359         { "glReplacementCodeuiColor3fVertex3fvSUN", NAME(glReplacementCodeuiColor3fVertex3fvSUN), _gloffset_ReplacementCodeuiColor3fVertex3fvSUN },
1360         { "glReplacementCodeuiNormal3fVertex3fSUN", NAME(glReplacementCodeuiNormal3fVertex3fSUN), _gloffset_ReplacementCodeuiNormal3fVertex3fSUN },
1361         { "glReplacementCodeuiNormal3fVertex3fvSUN", NAME(glReplacementCodeuiNormal3fVertex3fvSUN), _gloffset_ReplacementCodeuiNormal3fVertex3fvSUN },
1362         { "glReplacementCodeuiColor4fNormal3fVertex3fSUN", NAME(glReplacementCodeuiColor4fNormal3fVertex3fSUN), _gloffset_ReplacementCodeuiColor4fNormal3fVertex3fSUN },
1363         { "glReplacementCodeuiColor4fNormal3fVertex3fvSUN", NAME(glReplacementCodeuiColor4fNormal3fVertex3fvSUN), _gloffset_ReplacementCodeuiColor4fNormal3fVertex3fvSUN },
1364         { "glReplacementCodeuiTexCoord2fVertex3fSUN", NAME(glReplacementCodeuiTexCoord2fVertex3fSUN), _gloffset_ReplacementCodeuiTexCoord2fVertex3fSUN },
1365         { "glReplacementCodeuiTexCoord2fVertex3fvSUN", NAME(glReplacementCodeuiTexCoord2fVertex3fvSUN), _gloffset_ReplacementCodeuiTexCoord2fVertex3fvSUN },
1366         { "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", NAME(glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN), _gloffset_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN },
1367         { "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", NAME(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN), _gloffset_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN },
1368         { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", NAME(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN), _gloffset_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN },
1369         { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", NAME(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN), _gloffset_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN },
1370 #undef NAME
1371 #endif
1372
1373         /* 173. GL_EXT/INGR_blend_func_separate */
1374 #ifdef GL_EXT_blend_func_separate
1375 #define NAME(X) (GLvoid *) X
1376 #else
1377 #define NAME(X) (GLvoid *) NotImplemented
1378 #endif
1379         { "glBlendFuncSeparateEXT", NAME(glBlendFuncSeparateEXT), _gloffset_BlendFuncSeparateEXT },
1380         { "glBlendFuncSeparateINGR", NAME(glBlendFuncSeparateEXT), _gloffset_BlendFuncSeparateEXT },
1381 #undef NAME
1382
1383         /* 188. GL_EXT_vertex_weighting */
1384 #ifdef GL_EXT_vertex_weighting
1385 #define NAME(X) (GLvoid *) X
1386 #else
1387 #define NAME(X) (GLvoid *) NotImplemented
1388 #endif
1389         { "glVertexWeightfEXT", NAME(glVertexWeightfEXT), _gloffset_VertexWeightfEXT },
1390         { "glVertexWeightfvEXT", NAME(glVertexWeightfvEXT), _gloffset_VertexWeightfvEXT },
1391         { "glVertexWeightPointerEXT", NAME(glVertexWeightPointerEXT), _gloffset_VertexWeightPointerEXT },
1392 #undef NAME
1393
1394         /* 190. GL_NV_vertex_array_range */
1395 #ifdef GL_NV_vertex_array_range
1396 #define NAME(X) (GLvoid *) X
1397 #else
1398 #define NAME(X) (GLvoid *) NotImplemented
1399 #endif
1400         { "glFlushVertexArrayRangeNV", NAME(glFlushVertexArrayRangeNV), _gloffset_FlushVertexArrayRangeNV },
1401         { "glVertexArrayRangeNV", NAME(glVertexArrayRangeNV), _gloffset_VertexArrayRangeNV },
1402 #undef NAME
1403
1404         /* 191. GL_NV_register_combiners */
1405 #ifdef GL_NV_register_combiners
1406 #define NAME(X) (GLvoid *) X
1407 #else
1408 #define NAME(X) (GLvoid *) NotImplemented
1409 #endif
1410         { "glCombinerParameterfvNV", NAME(glCombinerParameterfvNV), _gloffset_CombinerParameterfvNV },
1411         { "glCombinerParameterfNV", NAME(glCombinerParameterfNV), _gloffset_CombinerParameterfNV },
1412         { "glCombinerParameterivNV", NAME(glCombinerParameterivNV), _gloffset_CombinerParameterivNV },
1413         { "glCombinerParameteriNV", NAME(glCombinerParameteriNV), _gloffset_CombinerParameteriNV },
1414         { "glCombinerInputNV", NAME(glCombinerInputNV), _gloffset_CombinerInputNV },
1415         { "glCombinerOutputNV", NAME(glCombinerOutputNV), _gloffset_CombinerOutputNV },
1416         { "glFinalCombinerInputNV", NAME(glFinalCombinerInputNV), _gloffset_FinalCombinerInputNV },
1417         { "glGetCombinerInputParameterfvNV", NAME(glGetCombinerInputParameterfvNV), _gloffset_GetCombinerInputParameterfvNV },
1418         { "glGetCombinerInputParameterivNV", NAME(glGetCombinerInputParameterivNV), _gloffset_GetCombinerInputParameterivNV },
1419         { "glGetCombinerOutputParameterfvNV", NAME(glGetCombinerOutputParameterfvNV), _gloffset_GetCombinerOutputParameterfvNV },
1420         { "glGetCombinerOutputParameterivNV", NAME(glGetCombinerOutputParameterivNV), _gloffset_GetCombinerOutputParameterivNV },
1421         { "glGetFinalCombinerInputParameterfvNV", NAME(glGetFinalCombinerInputParameterfvNV), _gloffset_GetFinalCombinerInputParameterfvNV },
1422         { "glGetFinalCombinerInputParameterivNV", NAME(glGetFinalCombinerInputParameterivNV), _gloffset_GetFinalCombinerInputParameterivNV },
1423 #undef NAME
1424
1425         /* 196. GL_MESA_resize_buffers */
1426 #ifdef MESA_resize_buffers
1427 #define NAME(X) (GLvoid *) X
1428 #else
1429 #define NAME(X) (GLvoid *) NotImplemented
1430 #endif
1431         { "glResizeBuffersMESA", NAME(glResizeBuffersMESA), _gloffset_ResizeBuffersMESA },
1432 #undef NAME
1433
1434         /* 197. GL_MESA_window_pos */
1435 #ifdef MESA_window_pos
1436 #define NAME(X) (GLvoid *) X
1437 #else
1438 #define NAME(X) (GLvoid *) NotImplemented
1439 #endif
1440         { "glWindowPos4fMESA", NAME(glWindowPos4fMESA), _gloffset_WindowPos4fMESA },
1441 #undef NAME
1442
1443         /* 209. WGL_EXT_multisample */
1444 #ifdef WGL_EXT_multisample
1445 #define NAME(X) (GLvoid *) X
1446 #else
1447 #define NAME(X) (GLvoid *) NotImplemented
1448 #endif
1449         { "glSampleMaskEXT", NAME(glSampleMaskEXT), _gloffset_SampleMaskSGIS },
1450         { "glSamplePatternEXT", NAME(glSamplePatternEXT), _gloffset_SamplePatternSGIS },
1451 #undef NAME
1452
1453         { NULL, NULL }  /* end of list marker */
1454 };
1455
1456
1457
1458 /*
1459  * Return dispatch table offset of the named static (built-in) function.
1460  * Return -1 if function not found.
1461  */
1462 static GLint
1463 get_static_proc_offset(const char *funcName)
1464 {
1465    GLuint i;
1466    for (i = 0; static_functions[i].Name; i++) {
1467       if (strcmp(static_functions[i].Name, funcName) == 0) {
1468          return static_functions[i].Offset;
1469       }
1470    }
1471    return -1;
1472 }
1473
1474
1475 /*
1476  * Return dispatch function address the named static (built-in) function.
1477  * Return NULL if function not found.
1478  */
1479 static GLvoid *
1480 get_static_proc_address(const char *funcName)
1481 {
1482    GLint i = get_static_proc_offset(funcName);
1483    if (i >= 0)
1484       return static_functions[i].Address;
1485    else
1486       return NULL;
1487 }
1488
1489
1490
1491 /**********************************************************************
1492  * Extension function management.
1493  */
1494
1495
1496 #define MAX_EXTENSION_FUNCS 1000
1497
1498 static struct name_address_offset ExtEntryTable[MAX_EXTENSION_FUNCS];
1499 static GLuint NumExtEntryPoints = 0;
1500
1501
1502
1503 /*
1504  * Generate a dispatch function (entrypoint) which jumps through
1505  * the given slot number (offset) in the current dispatch table.
1506  * We need assembly language in order to accomplish this.
1507  */
1508 static void *
1509 generate_entrypoint(GLuint functionOffset)
1510 {
1511 #if defined(USE_X86_ASM)
1512    /*
1513     * This x86 code contributed by Josh Vanderhoof.
1514     *
1515     *  0:   a1 10 32 54 76          movl   __glapi_Dispatch,%eax
1516     *       00 01 02 03 04
1517     *  5:   85 c0                   testl  %eax,%eax
1518     *       05 06
1519     *  7:   74 06                   je     f <entrypoint+0xf>
1520     *       07 08
1521     *  9:   ff a0 10 32 54 76       jmp    *0x76543210(%eax)
1522     *       09 0a 0b 0c 0d 0e
1523     *  f:   e8 fc ff ff ff          call   __glapi_get_dispatch
1524     *       0f 10 11 12 13
1525     * 14:   ff a0 10 32 54 76       jmp    *0x76543210(%eax)
1526     *       14 15 16 17 18 19
1527     */
1528    static const unsigned char temp[] = {
1529       0xa1, 0x00, 0x00, 0x00, 0x00,
1530       0x85, 0xc0,
1531       0x74, 0x06,
1532       0xff, 0xa0, 0x00, 0x00, 0x00, 0x00,
1533       0xe8, 0x00, 0x00, 0x00, 0x00,
1534       0xff, 0xa0, 0x00, 0x00, 0x00, 0x00
1535    };
1536    unsigned char *code = malloc(sizeof(temp));
1537    unsigned int next_insn;
1538    if (code) {
1539       memcpy(code, temp, sizeof(temp));
1540
1541       *(unsigned int *)(code + 0x01) = (unsigned int)&_glapi_Dispatch;
1542       *(unsigned int *)(code + 0x0b) = (unsigned int)functionOffset * 4;
1543       next_insn = (unsigned int)(code + 0x14);
1544       *(unsigned int *)(code + 0x10) = (unsigned int)_glapi_get_dispatch - next_insn;
1545       *(unsigned int *)(code + 0x16) = (unsigned int)functionOffset * 4;
1546    }
1547    return code;
1548 #else
1549    return NULL;
1550 #endif
1551 }
1552
1553
1554
1555 /*
1556  * Add a new extension function entrypoint.
1557  * Return: GL_TRUE = success or GL_FALSE = failure
1558  */
1559 GLboolean
1560 _glapi_add_entrypoint(const char *funcName, GLuint offset)
1561 {
1562    /* Make sure we don't try to add a new entrypoint after someone
1563     * has already called _glapi_get_dispatch_table_size()!  If that's
1564     * happened the caller's information will now be out of date.
1565     */
1566    assert(!GetSizeCalled);
1567
1568    /* first check if the named function is already statically present */
1569    {
1570       GLint index = get_static_proc_offset(funcName);
1571       if (index >= 0) {
1572          return (GLboolean) (index == offset);  /* bad offset! */
1573       }
1574    }
1575
1576    {
1577       /* make sure this offset/name pair is legal */
1578       const char *name = _glapi_get_proc_name(offset);
1579       if (name && strcmp(name, funcName) != 0)
1580          return GL_FALSE;  /* bad name! */
1581    }
1582
1583    {
1584       /* be sure index and name match known data */
1585       GLuint i;
1586       for (i = 0; i < NumExtEntryPoints; i++) {
1587          if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
1588             /* function already registered with api */
1589             if (ExtEntryTable[i].Offset == offset) {
1590                return GL_TRUE;  /* offsets match */
1591             }
1592             else {
1593                return GL_FALSE;  /* bad offset! */
1594             }
1595          }
1596       }
1597
1598       /* make sure we have space */
1599       if (NumExtEntryPoints >= MAX_EXTENSION_FUNCS) {
1600          return GL_FALSE;
1601       }
1602       else {
1603          void *entrypoint = generate_entrypoint(offset);
1604          if (!entrypoint)
1605             return GL_FALSE;
1606
1607          ExtEntryTable[NumExtEntryPoints].Name = str_dup(funcName);
1608          ExtEntryTable[NumExtEntryPoints].Offset = offset;
1609          ExtEntryTable[NumExtEntryPoints].Address = entrypoint;
1610          NumExtEntryPoints++;
1611
1612          if (offset > MaxDispatchOffset)
1613             MaxDispatchOffset = offset;
1614
1615          return GL_TRUE;  /* success */
1616       }
1617    }
1618
1619    /* should never get here, but play it safe */
1620    return GL_FALSE;
1621 }
1622
1623
1624
1625 #if 0000 /* prototype code for dynamic extension slot allocation */
1626
1627 static int NextFreeOffset = 409; /*XXX*/
1628 #define MAX_DISPATCH_TABLE_SIZE 1000
1629
1630 /*
1631  * Dynamically allocate a dispatch slot for an extension entrypoint
1632  * and generate the assembly language dispatch stub.
1633  * Return the dispatch offset for the function or -1 if no room or error.
1634  */
1635 GLint
1636 _glapi_add_entrypoint2(const char *funcName)
1637 {
1638    int offset;
1639
1640    /* first see if extension func is already known */
1641    offset = _glapi_get_proc_offset(funcName);
1642    if (offset >= 0)
1643       return offset;
1644
1645    if (NumExtEntryPoints < MAX_EXTENSION_FUNCS
1646        && NextFreeOffset < MAX_DISPATCH_TABLE_SIZE) {
1647       void *entryPoint;
1648       offset = NextFreeOffset;
1649       entryPoint = generate_entrypoint(offset);
1650       if (entryPoint) {
1651          NextFreeOffset++;
1652          ExtEntryTable[NumExtEntryPoints].Name = str_dup(funcName);
1653          ExtEntryTable[NumExtEntryPoints].Offset = offset;
1654          ExtEntryTable[NumExtEntryPoints].Address = entryPoint;
1655          NumExtEntryPoints++;
1656          return offset;
1657       }
1658    }
1659    return -1;
1660 }
1661
1662 #endif
1663
1664
1665
1666 /*
1667  * Return offset of entrypoint for named function within dispatch table.
1668  */
1669 GLint
1670 _glapi_get_proc_offset(const char *funcName)
1671 {
1672    /* search extension functions first */
1673    GLint i;
1674    for (i = 0; i < NumExtEntryPoints; i++) {
1675       if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
1676          return ExtEntryTable[i].Offset;
1677       }
1678    }
1679
1680    /* search static functions */
1681    return get_static_proc_offset(funcName);
1682 }
1683
1684
1685
1686 /*
1687  * Return entrypoint for named function.
1688  */
1689 const GLvoid *
1690 _glapi_get_proc_address(const char *funcName)
1691 {
1692    /* search extension functions first */
1693    GLint i;
1694    for (i = 0; i < NumExtEntryPoints; i++) {
1695       if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
1696          return ExtEntryTable[i].Address;
1697       }
1698    }
1699
1700    /* search static functions */
1701    return get_static_proc_address(funcName);
1702 }
1703
1704
1705
1706
1707 /*
1708  * Return the name of the function at the given dispatch offset.
1709  * This is only intended for debugging.
1710  */
1711 const char *
1712 _glapi_get_proc_name(GLuint offset)
1713 {
1714    const GLuint n = sizeof(static_functions) / sizeof(struct name_address_offset);
1715    GLuint i;
1716    for (i = 0; i < n; i++) {
1717       if (static_functions[i].Offset == offset)
1718          return static_functions[i].Name;
1719    }
1720
1721    /* search added extension functions */
1722    for (i = 0; i < NumExtEntryPoints; i++) {
1723       if (ExtEntryTable[i].Offset == offset) {
1724          return ExtEntryTable[i].Name;
1725       }
1726    }
1727    return NULL;
1728 }
1729
1730
1731
1732 /*
1733  * Make sure there are no NULL pointers in the given dispatch table.
1734  * Intented for debugging purposes.
1735  */
1736 void
1737 _glapi_check_table(const struct _glapi_table *table)
1738 {
1739    const GLuint entries = _glapi_get_dispatch_table_size();
1740    const void **tab = (const void **) table;
1741    GLuint i;
1742    for (i = 1; i < entries; i++) {
1743       assert(tab[i]);
1744    }
1745
1746 #ifdef DEBUG
1747    /* Do some spot checks to be sure that the dispatch table
1748     * slots are assigned correctly.
1749     */
1750    {
1751       GLuint BeginOffset = _glapi_get_proc_offset("glBegin");
1752       char *BeginFunc = (char*) &table->Begin;
1753       GLuint offset = (BeginFunc - (char *) table) / sizeof(void *);
1754       assert(BeginOffset == _gloffset_Begin);
1755       assert(BeginOffset == offset);
1756    }
1757    {
1758       GLuint viewportOffset = _glapi_get_proc_offset("glViewport");
1759       char *viewportFunc = (char*) &table->Viewport;
1760       GLuint offset = (viewportFunc - (char *) table) / sizeof(void *);
1761       assert(viewportOffset == _gloffset_Viewport);
1762       assert(viewportOffset == offset);
1763    }
1764    {
1765       GLuint VertexPointerOffset = _glapi_get_proc_offset("glVertexPointer");
1766       char *VertexPointerFunc = (char*) &table->VertexPointer;
1767       GLuint offset = (VertexPointerFunc - (char *) table) / sizeof(void *);
1768       assert(VertexPointerOffset == _gloffset_VertexPointer);
1769       assert(VertexPointerOffset == offset);
1770    }
1771    {
1772       GLuint ResetMinMaxOffset = _glapi_get_proc_offset("glResetMinmax");
1773       char *ResetMinMaxFunc = (char*) &table->ResetMinmax;
1774       GLuint offset = (ResetMinMaxFunc - (char *) table) / sizeof(void *);
1775       assert(ResetMinMaxOffset == _gloffset_ResetMinmax);
1776       assert(ResetMinMaxOffset == offset);
1777    }
1778    {
1779       GLuint blendColorOffset = _glapi_get_proc_offset("glBlendColor");
1780       char *blendColorFunc = (char*) &table->BlendColor;
1781       GLuint offset = (blendColorFunc - (char *) table) / sizeof(void *);
1782       assert(blendColorOffset == _gloffset_BlendColor);
1783       assert(blendColorOffset == offset);
1784    }
1785    {
1786       GLuint istextureOffset = _glapi_get_proc_offset("glIsTextureEXT");
1787       char *istextureFunc = (char*) &table->IsTextureEXT;
1788       GLuint offset = (istextureFunc - (char *) table) / sizeof(void *);
1789       assert(istextureOffset == _gloffset_IsTextureEXT);
1790       assert(istextureOffset == offset);
1791    }
1792 #endif
1793 }
1794
1795
1796
1797