src/mesa/glapi/glapi.c

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