src/mesa/glapi/glapi.c

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