src/mesa/glapi/glapi.c

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