src/mesa/glapi/glapi.c

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