src/mesa/glapi/glapi.c

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