src/mesa/glapi/glapi.c

   1 /* $Id: glapi.c,v 1.8 1999/11/19 22:33:50 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.3
   6  *
   7  * Copyright (C) 1999  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 #include <assert.h>
  29 #include <stdlib.h>  /* to get NULL */
  30 #include <string.h>
  31 #include "glapi.h"
  32 #include "glapinoop.h"
  33
  34
  35
  36 /*
  37  * Define the DISPATCH_SETUP and DISPATCH macros here dependant on
  38  * whether or not threading is enabled.
  39  */
  40 #if defined(THREADS)
  41
  42 /*** Thread-safe API dispatch ***/
  43 #include "mthreads.h"
  44 static MesaTSD mesa_dispatch_tsd;
  45 static void mesa_dispatch_thread_init() {
  46   MesaInitTSD(&mesa_dispatch_tsd);
  47 }
  48 #define DISPATCH_SETUP struct _glapi_table *dispatch = (struct _glapi_table *) MesaGetTSD(&mesa_dispatch_tsd)
  49 #define DISPATCH(FUNC) (dispatch->FUNC)
  50
  51
  52 #else
  53
  54 /*** Non-threaded API dispatch ***/
  55 static struct _glapi_table *Dispatch = &__glapi_noop_table;
  56 #define DISPATCH_SETUP
  57 #define DISPATCH(FUNC) (Dispatch->FUNC)
  58
  59 #endif
  60
  61
  62
  63 /*
  64  * Set the global or per-thread dispatch table pointer.
  65  */
  66 void
  67 _glapi_set_dispatch(struct _glapi_table *dispatch)
  68 {
  69    if (!dispatch) {
  70       /* use the no-op functions */
  71       dispatch = &__glapi_noop_table;
  72    }
  73 #ifdef DEBUG
  74    else {
  75       _glapi_check_table(dispatch);
  76    }
  77 #endif
  78
  79 #if defined(THREADS)
  80    MesaSetTSD(&mesa_dispatch_tsd, (void*) dispatch, mesa_dispatch_thread_init);
  81 #else
  82    Dispatch = dispatch;
  83 #endif
  84 }
  85
  86
  87 /*
  88  * Get the global or per-thread dispatch table pointer.
  89  */
  90 struct _glapi_table *
  91 _glapi_get_dispatch(void)
  92 {
  93 #if defined(THREADS)
  94    /* return this thread's dispatch pointer */
  95    return (struct _glapi_table *) MesaGetTSD(&mesa_dispatch_tsd);
  96 #else
  97    return Dispatch;
  98 #endif
  99 }
 100
 101
 102 /*
 103  * Get API dispatcher version string.
 104  * XXX this isn't well defined yet.
 105  */
 106 const char *
 107 _glapi_get_version(void)
 108 {
 109    return "1.2";
 110 }
 111
 112
 113 /*
 114  * Return list of hard-coded extension entrypoints in the dispatch table.
 115  * XXX this isn't well defined yet.
 116  */
 117 const char *
 118 _glapi_get_extensions(void)
 119 {
 120    return "GL_EXT_paletted_texture GL_EXT_compiled_vertex_array GL_EXT_point_parameters GL_EXT_polygon_offset GL_EXT_blend_minmax GL_EXT_blend_color GL_ARB_multitexture GL_INGR_blend_func_separate GL_MESA_window_pos GL_MESA_resize_buffers";
 121 }
 122
 123
 124
 125 /*
 126  * XXX the following dynamic extension code is just a prototype and
 127  * not used yet.
 128  */
 129 struct _glapi_ext_entrypoint {
 130    const char *Name;
 131    GLuint Offset;
 132 };
 133
 134 #define MAX_EXT_ENTRYPOINTS 100
 135
 136 static struct _glapi_ext_entrypoint ExtEntryTable[MAX_EXT_ENTRYPOINTS];
 137 static GLuint NumExtEntryPoints;
 138
 139
 140
 141 /*
 142  * Dynamically allocate an extension entry point.
 143  * Return a slot number or -1 if table is full.
 144  */
 145 GLint
 146 _glapi_alloc_entrypoint(const char *funcName)
 147 {
 148    GLuint i;
 149    for (i = 0; i < NumExtEntryPoints; i++) {
 150       if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
 151          /* found it */
 152          return (GLint) ExtEntryTable[i].Offset;
 153       }
 154    }
 155    if (NumExtEntryPoints < MAX_EXT_ENTRYPOINTS) {
 156       /* add it */
 157       ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
 158       ExtEntryTable[NumExtEntryPoints].Offset = NumExtEntryPoints; /* OK? */
 159       NumExtEntryPoints++;
 160       return (GLint) (NumExtEntryPoints - 1);
 161    }
 162    /* no more room in the table */
 163    return -1;
 164 }
 165
 166
 167
 168 /*
 169  * Find the dynamic entry point for the named function.
 170  * Return a slot number or -1 if not found.
 171  */
 172 GLint
 173 _glapi_get_entrypoint(const char *funcName)
 174 {
 175    GLuint i;
 176    for (i = 0; i < NumExtEntryPoints; i++) {
 177       if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
 178          /* found it */
 179          return (GLint) ExtEntryTable[i].Offset;
 180       }
 181    }
 182    /* not in table */
 183    return -1;
 184 }
 185
 186
 187
 188 static GLvoid *
 189 get_static_proc_address(const char *funcName)
 190 {
 191    struct name_address {
 192       const char *Name;
 193       GLvoid *Address;
 194    };
 195    static struct name_address apitable[] = {
 196       { "glAccum", (GLvoid *) glAccum },
 197       { "glAlphaFunc", (GLvoid *) glAlphaFunc },
 198       { "glBegin", (GLvoid *) glBegin },
 199       { "glBitmap", (GLvoid *) glBitmap },
 200       /* ... many more ... */
 201       { NULL, NULL }  /* end of list marker */
 202    };
 203    GLuint i;
 204    for (i = 0; apitable[i].Name; i++) {
 205       if (strcmp(apitable[i].Name, funcName) == 0) {
 206          return apitable[i].Address;
 207       }
 208    }
 209    return NULL;
 210 }
 211
 212
 213 /*
 214  * Return entrypoint for named function.
 215  */
 216 const GLvoid *
 217 _glapi_get_proc_address(const char *funcName)
 218 {
 219    /* look for dynamic extension entry point */
 220
 221    /* look for static entry point */
 222    return get_static_proc_address(funcName);
 223 }
 224
 225
 226
 227 /*
 228  * Make sure there are no NULL pointers in the given dispatch table.
 229  * Intented for debugging purposes.
 230  */
 231 void
 232 _glapi_check_table(const struct _glapi_table *table)
 233 {
 234    assert(table->Accum);
 235    assert(table->AlphaFunc);
 236    assert(table->Begin);
 237    assert(table->Bitmap);
 238    assert(table->BlendFunc);
 239    assert(table->CallList);
 240    assert(table->CallLists);
 241    assert(table->Clear);
 242    assert(table->ClearAccum);
 243    assert(table->ClearColor);
 244    assert(table->ClearDepth);
 245    assert(table->ClearIndex);
 246    assert(table->ClearStencil);
 247    assert(table->ClipPlane);
 248    assert(table->Color3b);
 249    assert(table->Color3bv);
 250    assert(table->Color3d);
 251    assert(table->Color3dv);
 252    assert(table->Color3f);
 253    assert(table->Color3fv);
 254    assert(table->Color3i);
 255    assert(table->Color3iv);
 256    assert(table->Color3s);
 257    assert(table->Color3sv);
 258    assert(table->Color3ub);
 259    assert(table->Color3ubv);
 260    assert(table->Color3ui);
 261    assert(table->Color3uiv);
 262    assert(table->Color3us);
 263    assert(table->Color3usv);
 264    assert(table->Color4b);
 265    assert(table->Color4bv);
 266    assert(table->Color4d);
 267    assert(table->Color4dv);
 268    assert(table->Color4f);
 269    assert(table->Color4fv);
 270    assert(table->Color4i);
 271    assert(table->Color4iv);
 272    assert(table->Color4s);
 273    assert(table->Color4sv);
 274    assert(table->Color4ub);
 275    assert(table->Color4ubv);
 276    assert(table->Color4ui);
 277    assert(table->Color4uiv);
 278    assert(table->Color4us);
 279    assert(table->Color4usv);
 280    assert(table->ColorMask);
 281    assert(table->ColorMaterial);
 282    assert(table->CopyPixels);
 283    assert(table->CullFace);
 284    assert(table->DeleteLists);
 285    assert(table->DepthFunc);
 286    assert(table->DepthMask);
 287    assert(table->DepthRange);
 288    assert(table->Disable);
 289    assert(table->DrawBuffer);
 290    assert(table->DrawElements);
 291    assert(table->DrawPixels);
 292    assert(table->EdgeFlag);
 293    assert(table->EdgeFlagv);
 294    assert(table->Enable);
 295    assert(table->End);
 296    assert(table->EndList);
 297    assert(table->EvalCoord1d);
 298    assert(table->EvalCoord1dv);
 299    assert(table->EvalCoord1f);
 300    assert(table->EvalCoord1fv);
 301    assert(table->EvalCoord2d);
 302    assert(table->EvalCoord2dv);
 303    assert(table->EvalCoord2f);
 304    assert(table->EvalCoord2fv);
 305    assert(table->EvalMesh1);
 306    assert(table->EvalMesh2);
 307    assert(table->EvalPoint1);
 308    assert(table->EvalPoint2);
 309    assert(table->FeedbackBuffer);
 310    assert(table->Finish);
 311    assert(table->Flush);
 312    assert(table->Fogf);
 313    assert(table->Fogfv);
 314    assert(table->Fogi);
 315    assert(table->Fogiv);
 316    assert(table->FrontFace);
 317    assert(table->Frustum);
 318    assert(table->GenLists);
 319    assert(table->GetBooleanv);
 320    assert(table->GetClipPlane);
 321    assert(table->GetDoublev);
 322    assert(table->GetError);
 323    assert(table->GetFloatv);
 324    assert(table->GetIntegerv);
 325    assert(table->GetLightfv);
 326    assert(table->GetLightiv);
 327    assert(table->GetMapdv);
 328    assert(table->GetMapfv);
 329    assert(table->GetMapiv);
 330    assert(table->GetMaterialfv);
 331    assert(table->GetMaterialiv);
 332    assert(table->GetPixelMapfv);
 333    assert(table->GetPixelMapuiv);
 334    assert(table->GetPixelMapusv);
 335    assert(table->GetPolygonStipple);
 336    assert(table->GetString);
 337    assert(table->GetTexEnvfv);
 338    assert(table->GetTexEnviv);
 339    assert(table->GetTexGendv);
 340    assert(table->GetTexGenfv);
 341    assert(table->GetTexGeniv);
 342    assert(table->GetTexImage);
 343    assert(table->GetTexLevelParameterfv);
 344    assert(table->GetTexLevelParameteriv);
 345    assert(table->GetTexParameterfv);
 346    assert(table->GetTexParameteriv);
 347    assert(table->Hint);
 348    assert(table->IndexMask);
 349    assert(table->Indexd);
 350    assert(table->Indexdv);
 351    assert(table->Indexf);
 352    assert(table->Indexfv);
 353    assert(table->Indexi);
 354    assert(table->Indexiv);
 355    assert(table->Indexs);
 356    assert(table->Indexsv);
 357    assert(table->InitNames);
 358    assert(table->IsEnabled);
 359    assert(table->IsList);
 360    assert(table->LightModelf);
 361    assert(table->LightModelfv);
 362    assert(table->LightModeli);
 363    assert(table->LightModeliv);
 364    assert(table->Lightf);
 365    assert(table->Lightfv);
 366    assert(table->Lighti);
 367    assert(table->Lightiv);
 368    assert(table->LineStipple);
 369    assert(table->LineWidth);
 370    assert(table->ListBase);
 371    assert(table->LoadIdentity);
 372    assert(table->LoadMatrixd);
 373    assert(table->LoadMatrixf);
 374    assert(table->LoadName);
 375    assert(table->LogicOp);
 376    assert(table->Map1d);
 377    assert(table->Map1f);
 378    assert(table->Map2d);
 379    assert(table->Map2f);
 380    assert(table->MapGrid1d);
 381    assert(table->MapGrid1f);
 382    assert(table->MapGrid2d);
 383    assert(table->MapGrid2f);
 384    assert(table->Materialf);
 385    assert(table->Materialfv);
 386    assert(table->Materiali);
 387    assert(table->Materialiv);
 388    assert(table->MatrixMode);
 389    assert(table->MultMatrixd);
 390    assert(table->MultMatrixf);
 391    assert(table->NewList);
 392    assert(table->Normal3b);
 393    assert(table->Normal3bv);
 394    assert(table->Normal3d);
 395    assert(table->Normal3dv);
 396    assert(table->Normal3f);
 397    assert(table->Normal3fv);
 398    assert(table->Normal3i);
 399    assert(table->Normal3iv);
 400    assert(table->Normal3s);
 401    assert(table->Normal3sv);
 402    assert(table->Ortho);
 403    assert(table->PassThrough);
 404    assert(table->PixelMapfv);
 405    assert(table->PixelMapuiv);
 406    assert(table->PixelMapusv);
 407    assert(table->PixelStoref);
 408    assert(table->PixelStorei);
 409    assert(table->PixelTransferf);
 410    assert(table->PixelTransferi);
 411    assert(table->PixelZoom);
 412    assert(table->PointSize);
 413    assert(table->PolygonMode);
 414    assert(table->PolygonOffset);
 415    assert(table->PolygonStipple);
 416    assert(table->PopAttrib);
 417    assert(table->PopMatrix);
 418    assert(table->PopName);
 419    assert(table->PushAttrib);
 420    assert(table->PushMatrix);
 421    assert(table->PushName);
 422    assert(table->RasterPos2d);
 423    assert(table->RasterPos2dv);
 424    assert(table->RasterPos2f);
 425    assert(table->RasterPos2fv);
 426    assert(table->RasterPos2i);
 427    assert(table->RasterPos2iv);
 428    assert(table->RasterPos2s);
 429    assert(table->RasterPos2sv);
 430    assert(table->RasterPos3d);
 431    assert(table->RasterPos3dv);
 432    assert(table->RasterPos3f);
 433    assert(table->RasterPos3fv);
 434    assert(table->RasterPos3i);
 435    assert(table->RasterPos3iv);
 436    assert(table->RasterPos3s);
 437    assert(table->RasterPos3sv);
 438    assert(table->RasterPos4d);
 439    assert(table->RasterPos4dv);
 440    assert(table->RasterPos4f);
 441    assert(table->RasterPos4fv);
 442    assert(table->RasterPos4i);
 443    assert(table->RasterPos4iv);
 444    assert(table->RasterPos4s);
 445    assert(table->RasterPos4sv);
 446    assert(table->ReadBuffer);
 447    assert(table->ReadPixels);
 448    assert(table->Rectd);
 449    assert(table->Rectdv);
 450    assert(table->Rectf);
 451    assert(table->Rectfv);
 452    assert(table->Recti);
 453    assert(table->Rectiv);
 454    assert(table->Rects);
 455    assert(table->Rectsv);
 456    assert(table->RenderMode);
 457    assert(table->Rotated);
 458    assert(table->Rotatef);
 459    assert(table->Scaled);
 460    assert(table->Scalef);
 461    assert(table->Scissor);
 462    assert(table->SelectBuffer);
 463    assert(table->ShadeModel);
 464    assert(table->StencilFunc);
 465    assert(table->StencilMask);
 466    assert(table->StencilOp);
 467    assert(table->TexCoord1d);
 468    assert(table->TexCoord1dv);
 469    assert(table->TexCoord1f);
 470    assert(table->TexCoord1fv);
 471    assert(table->TexCoord1i);
 472    assert(table->TexCoord1iv);
 473    assert(table->TexCoord1s);
 474    assert(table->TexCoord1sv);
 475    assert(table->TexCoord2d);
 476    assert(table->TexCoord2dv);
 477    assert(table->TexCoord2f);
 478    assert(table->TexCoord2fv);
 479    assert(table->TexCoord2i);
 480    assert(table->TexCoord2iv);
 481    assert(table->TexCoord2s);
 482    assert(table->TexCoord2sv);
 483    assert(table->TexCoord3d);
 484    assert(table->TexCoord3dv);
 485    assert(table->TexCoord3f);
 486    assert(table->TexCoord3fv);
 487    assert(table->TexCoord3i);
 488    assert(table->TexCoord3iv);
 489    assert(table->TexCoord3s);
 490    assert(table->TexCoord3sv);
 491    assert(table->TexCoord4d);
 492    assert(table->TexCoord4dv);
 493    assert(table->TexCoord4f);
 494    assert(table->TexCoord4fv);
 495    assert(table->TexCoord4i);
 496    assert(table->TexCoord4iv);
 497    assert(table->TexCoord4s);
 498    assert(table->TexCoord4sv);
 499    assert(table->TexEnvf);
 500    assert(table->TexEnvfv);
 501    assert(table->TexEnvi);
 502    assert(table->TexEnviv);
 503    assert(table->TexGend);
 504    assert(table->TexGendv);
 505    assert(table->TexGenf);
 506    assert(table->TexGenfv);
 507    assert(table->TexGeni);
 508    assert(table->TexGeniv);
 509    assert(table->TexImage1D);
 510    assert(table->TexImage2D);
 511    assert(table->TexParameterf);
 512    assert(table->TexParameterfv);
 513    assert(table->TexParameteri);
 514    assert(table->TexParameteriv);
 515    assert(table->Translated);
 516    assert(table->Translatef);
 517    assert(table->Vertex2d);
 518    assert(table->Vertex2dv);
 519    assert(table->Vertex2f);
 520    assert(table->Vertex2fv);
 521    assert(table->Vertex2i);
 522    assert(table->Vertex2iv);
 523    assert(table->Vertex2s);
 524    assert(table->Vertex2sv);
 525    assert(table->Vertex3d);
 526    assert(table->Vertex3dv);
 527    assert(table->Vertex3f);
 528    assert(table->Vertex3fv);
 529    assert(table->Vertex3i);
 530    assert(table->Vertex3iv);
 531    assert(table->Vertex3s);
 532    assert(table->Vertex3sv);
 533    assert(table->Vertex4d);
 534    assert(table->Vertex4dv);
 535    assert(table->Vertex4f);
 536    assert(table->Vertex4fv);
 537    assert(table->Vertex4i);
 538    assert(table->Vertex4iv);
 539    assert(table->Vertex4s);
 540    assert(table->Vertex4sv);
 541    assert(table->Viewport);
 542
 543 #ifdef _GLAPI_VERSION_1_1
 544    assert(table->AreTexturesResident);
 545    assert(table->ArrayElement);
 546    assert(table->BindTexture);
 547    assert(table->ColorPointer);
 548    assert(table->CopyTexImage1D);
 549    assert(table->CopyTexImage2D);
 550    assert(table->CopyTexSubImage1D);
 551    assert(table->CopyTexSubImage2D);
 552    assert(table->DeleteTextures);
 553    assert(table->DisableClientState);
 554    assert(table->DrawArrays);
 555    assert(table->EdgeFlagPointer);
 556    assert(table->EnableClientState);
 557    assert(table->GenTextures);
 558    assert(table->GetPointerv);
 559    assert(table->IndexPointer);
 560    assert(table->Indexub);
 561    assert(table->Indexubv);
 562    assert(table->InterleavedArrays);
 563    assert(table->IsTexture);
 564    assert(table->NormalPointer);
 565    assert(table->PopClientAttrib);
 566    assert(table->PrioritizeTextures);
 567    assert(table->PushClientAttrib);
 568    assert(table->TexCoordPointer);
 569    assert(table->TexSubImage1D);
 570    assert(table->TexSubImage2D);
 571    assert(table->VertexPointer);
 572 #endif
 573
 574 #ifdef _GLAPI_VERSION_1_2
 575    assert(table->CopyTexSubImage3D);
 576    assert(table->DrawRangeElements);
 577    assert(table->TexImage3D);
 578    assert(table->TexSubImage3D);
 579 #ifdef _GLAPI_ARB_imaging
 580    assert(table->BlendColor);
 581    assert(table->BlendEquation);
 582    assert(table->ColorSubTable);
 583    assert(table->ColorTable);
 584    assert(table->ColorTableParameterfv);
 585    assert(table->ColorTableParameteriv);
 586    assert(table->ConvolutionFilter1D);
 587    assert(table->ConvolutionFilter2D);
 588    assert(table->ConvolutionParameterf);
 589    assert(table->ConvolutionParameterfv);
 590    assert(table->ConvolutionParameteri);
 591    assert(table->ConvolutionParameteriv);
 592    assert(table->CopyColorSubTable);
 593    assert(table->CopyColorTable);
 594    assert(table->CopyConvolutionFilter1D);
 595    assert(table->CopyConvolutionFilter2D);
 596    assert(table->GetColorTable);
 597    assert(table->GetColorTableParameterfv);
 598    assert(table->GetColorTableParameteriv);
 599    assert(table->GetConvolutionFilter);
 600    assert(table->GetConvolutionParameterfv);
 601    assert(table->GetConvolutionParameteriv);
 602    assert(table->GetHistogram);
 603    assert(table->GetHistogramParameterfv);
 604    assert(table->GetHistogramParameteriv);
 605    assert(table->GetMinmax);
 606    assert(table->GetMinmaxParameterfv);
 607    assert(table->GetMinmaxParameteriv);
 608    assert(table->Histogram);
 609    assert(table->Minmax);
 610    assert(table->ResetHistogram);
 611    assert(table->ResetMinmax);
 612    assert(table->SeparableFilter2D);
 613 #endif
 614 #endif
 615
 616
 617 #ifdef _GLAPI_EXT_paletted_texture
 618    assert(table->ColorTableEXT);
 619    assert(table->ColorSubTableEXT);
 620    assert(table->GetColorTableEXT);
 621    assert(table->GetColorTableParameterfvEXT);
 622    assert(table->GetColorTableParameterivEXT);
 623 #endif
 624
 625 #ifdef _GLAPI_EXT_compiled_vertex_array
 626    assert(table->LockArraysEXT);
 627    assert(table->UnlockArraysEXT);
 628 #endif
 629
 630 #ifdef _GLAPI_EXT_point_parameter
 631    assert(table->PointParameterfEXT);
 632    assert(table->PointParameterfvEXT);
 633 #endif
 634
 635 #ifdef _GLAPI_EXT_polygon_offset
 636    assert(table->PolygonOffsetEXT);
 637 #endif
 638
 639 #ifdef _GLAPI_ARB_multitexture
 640    assert(table->ActiveTextureARB);
 641    assert(table->ClientActiveTextureARB);
 642    assert(table->MultiTexCoord1dARB);
 643    assert(table->MultiTexCoord1dvARB);
 644    assert(table->MultiTexCoord1fARB);
 645    assert(table->MultiTexCoord1fvARB);
 646    assert(table->MultiTexCoord1iARB);
 647    assert(table->MultiTexCoord1ivARB);
 648    assert(table->MultiTexCoord1sARB);
 649    assert(table->MultiTexCoord1svARB);
 650    assert(table->MultiTexCoord2dARB);
 651    assert(table->MultiTexCoord2dvARB);
 652    assert(table->MultiTexCoord2fARB);
 653    assert(table->MultiTexCoord2fvARB);
 654    assert(table->MultiTexCoord2iARB);
 655    assert(table->MultiTexCoord2ivARB);
 656    assert(table->MultiTexCoord2sARB);
 657    assert(table->MultiTexCoord2svARB);
 658    assert(table->MultiTexCoord3dARB);
 659    assert(table->MultiTexCoord3dvARB);
 660    assert(table->MultiTexCoord3fARB);
 661    assert(table->MultiTexCoord3fvARB);
 662    assert(table->MultiTexCoord3iARB);
 663    assert(table->MultiTexCoord3ivARB);
 664    assert(table->MultiTexCoord3sARB);
 665    assert(table->MultiTexCoord3svARB);
 666    assert(table->MultiTexCoord4dARB);
 667    assert(table->MultiTexCoord4dvARB);
 668    assert(table->MultiTexCoord4fARB);
 669    assert(table->MultiTexCoord4fvARB);
 670    assert(table->MultiTexCoord4iARB);
 671    assert(table->MultiTexCoord4ivARB);
 672    assert(table->MultiTexCoord4sARB);
 673    assert(table->MultiTexCoord4svARB);
 674 #endif
 675
 676 #ifdef _GLAPI_INGR_blend_func_separate
 677    assert(table->BlendFuncSeparateINGR);
 678 #endif
 679
 680 #ifdef _GLAPI_MESA_window_pos
 681    assert(table->WindowPos4fMESA);
 682 #endif
 683
 684 #ifdef _GLAPI_MESA_resize_buffers
 685    assert(table->ResizeBuffersMESA);
 686 #endif
 687 }
 688
 689
 690
 691 void GLAPIENTRY glAccum(GLenum op, GLfloat value)
 692 {
 693    DISPATCH_SETUP;
 694    DISPATCH(Accum)(op, value);
 695 }
 696
 697 void GLAPIENTRY glAlphaFunc(GLenum func, GLclampf ref)
 698 {
 699    DISPATCH_SETUP;
 700    DISPATCH(AlphaFunc)(func, ref);
 701 }
 702
 703 void GLAPIENTRY glBegin(GLenum mode)
 704 {
 705    DISPATCH_SETUP;
 706    DISPATCH(Begin)(mode);
 707 }
 708
 709 void GLAPIENTRY glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 710 {
 711    DISPATCH_SETUP;
 712    DISPATCH(Bitmap)(width, height, xorig, yorig, xmove, ymove, bitmap);
 713 }
 714
 715 void GLAPIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
 716 {
 717    DISPATCH_SETUP;
 718    DISPATCH(BlendFunc)(sfactor, dfactor);
 719 }
 720
 721 void GLAPIENTRY glCallList(GLuint list)
 722 {
 723    DISPATCH_SETUP;
 724    DISPATCH(CallList)(list);
 725 }
 726
 727 void GLAPIENTRY glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 728 {
 729    DISPATCH_SETUP;
 730    DISPATCH(CallLists)(n, type, lists);
 731 }
 732
 733 void GLAPIENTRY glClear(GLbitfield mask)
 734 {
 735    DISPATCH_SETUP;
 736    DISPATCH(Clear)(mask);
 737 }
 738
 739 void GLAPIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 740 {
 741    DISPATCH_SETUP;
 742    DISPATCH(ClearAccum)(red, green, blue, alpha);
 743 }
 744
 745 void GLAPIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 746 {
 747    DISPATCH_SETUP;
 748    DISPATCH(ClearColor)(red, green, blue, alpha);
 749 }
 750
 751 void GLAPIENTRY glClearDepth(GLclampd depth)
 752 {
 753    DISPATCH_SETUP;
 754    DISPATCH(ClearDepth)(depth);
 755 }
 756
 757 void GLAPIENTRY glClearIndex(GLfloat c)
 758 {
 759    DISPATCH_SETUP;
 760    DISPATCH(ClearIndex)(c);
 761 }
 762
 763 void GLAPIENTRY glClearStencil(GLint s)
 764 {
 765    DISPATCH_SETUP;
 766    DISPATCH(ClearStencil)(s);
 767 }
 768
 769 void GLAPIENTRY glClipPlane(GLenum plane, const GLdouble *equation)
 770 {
 771    DISPATCH_SETUP;
 772    DISPATCH(ClipPlane)(plane, equation);
 773 }
 774
 775 void GLAPIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 776 {
 777    DISPATCH_SETUP;
 778    DISPATCH(Color3b)(red, green, blue);
 779 }
 780
 781 void GLAPIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 782 {
 783    DISPATCH_SETUP;
 784    DISPATCH(Color3d)(red, green, blue);
 785 }
 786
 787 void GLAPIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 788 {
 789    DISPATCH_SETUP;
 790    DISPATCH(Color3f)(red, green, blue);
 791 }
 792
 793 void GLAPIENTRY glColor3i(GLint red, GLint green, GLint blue)
 794 {
 795    DISPATCH_SETUP;
 796    DISPATCH(Color3i)(red, green, blue);
 797 }
 798
 799 void GLAPIENTRY glColor3s(GLshort red, GLshort green, GLshort blue)
 800 {
 801    DISPATCH_SETUP;
 802    DISPATCH(Color3s)(red, green, blue);
 803 }
 804
 805 void GLAPIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 806 {
 807    DISPATCH_SETUP;
 808    DISPATCH(Color3ub)(red, green, blue);
 809 }
 810
 811 void GLAPIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue)
 812 {
 813    DISPATCH_SETUP;
 814    DISPATCH(Color3ui)(red, green, blue);
 815 }
 816
 817 void GLAPIENTRY glColor3us(GLushort red, GLushort green, GLushort blue)
 818 {
 819    DISPATCH_SETUP;
 820    DISPATCH(Color3us)(red, green, blue);
 821 }
 822
 823 void GLAPIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 824 {
 825    DISPATCH_SETUP;
 826    DISPATCH(Color4b)(red, green, blue, alpha);
 827 }
 828
 829 void GLAPIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 830 {
 831    DISPATCH_SETUP;
 832    DISPATCH(Color4d)(red, green, blue, alpha);
 833 }
 834
 835 void GLAPIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 836 {
 837    DISPATCH_SETUP;
 838    DISPATCH(Color4f)(red, green, blue, alpha);
 839 }
 840
 841 void GLAPIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 842 {
 843    DISPATCH_SETUP;
 844    DISPATCH(Color4i)(red, green, blue, alpha);
 845 }
 846
 847 void GLAPIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 848 {
 849    DISPATCH_SETUP;
 850    DISPATCH(Color4s)(red, green, blue, alpha);
 851 }
 852
 853 void GLAPIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 854 {
 855    DISPATCH_SETUP;
 856    DISPATCH(Color4ub)(red, green, blue, alpha);
 857 }
 858
 859 void GLAPIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 860 {
 861    DISPATCH_SETUP;
 862    DISPATCH(Color4ui)(red, green, blue, alpha);
 863 }
 864
 865 void GLAPIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 866 {
 867    DISPATCH_SETUP;
 868    DISPATCH(Color4us)(red, green, blue, alpha);
 869 }
 870
 871 void GLAPIENTRY glColor3bv(const GLbyte *v)
 872 {
 873    DISPATCH_SETUP;
 874    DISPATCH(Color3bv)(v);
 875 }
 876
 877 void GLAPIENTRY glColor3dv(const GLdouble *v)
 878 {
 879    DISPATCH_SETUP;
 880    DISPATCH(Color3dv)(v);
 881 }
 882
 883 void GLAPIENTRY glColor3fv(const GLfloat *v)
 884 {
 885    DISPATCH_SETUP;
 886    DISPATCH(Color3fv)(v);
 887 }
 888
 889 void GLAPIENTRY glColor3iv(const GLint *v)
 890 {
 891    DISPATCH_SETUP;
 892    DISPATCH(Color3iv)(v);
 893 }
 894
 895 void GLAPIENTRY glColor3sv(const GLshort *v)
 896 {
 897    DISPATCH_SETUP;
 898    DISPATCH(Color3sv)(v);
 899 }
 900
 901 void GLAPIENTRY glColor3ubv(const GLubyte *v)
 902 {
 903    DISPATCH_SETUP;
 904    DISPATCH(Color3ubv)(v);
 905 }
 906
 907 void GLAPIENTRY glColor3uiv(const GLuint *v)
 908 {
 909    DISPATCH_SETUP;
 910    DISPATCH(Color3uiv)(v);
 911 }
 912
 913 void GLAPIENTRY glColor3usv(const GLushort *v)
 914 {
 915    DISPATCH_SETUP;
 916    DISPATCH(Color3usv)(v);
 917 }
 918
 919 void GLAPIENTRY glColor4bv(const GLbyte *v)
 920 {
 921    DISPATCH_SETUP;
 922    DISPATCH(Color4bv)(v);
 923 }
 924
 925 void GLAPIENTRY glColor4dv(const GLdouble *v)
 926 {
 927    DISPATCH_SETUP;
 928    DISPATCH(Color4dv)(v);
 929 }
 930
 931 void GLAPIENTRY glColor4fv(const GLfloat *v)
 932 {
 933    DISPATCH_SETUP;
 934    DISPATCH(Color4fv)(v);
 935 }
 936
 937 void GLAPIENTRY glColor4iv(const GLint *v)
 938 {
 939    DISPATCH_SETUP;
 940    DISPATCH(Color4iv)(v);
 941 }
 942
 943 void GLAPIENTRY glColor4sv(const GLshort *v)
 944 {
 945    DISPATCH_SETUP;
 946    DISPATCH(Color4sv)(v);
 947 }
 948
 949 void GLAPIENTRY glColor4ubv(const GLubyte *v)
 950 {
 951    DISPATCH_SETUP;
 952    DISPATCH(Color4ubv)(v);
 953 }
 954
 955 void GLAPIENTRY glColor4uiv(const GLuint *v)
 956 {
 957    DISPATCH_SETUP;
 958    DISPATCH(Color4uiv)(v);
 959 }
 960
 961 void GLAPIENTRY glColor4usv(const GLushort *v)
 962 {
 963    DISPATCH_SETUP;
 964    DISPATCH(Color4usv)(v);
 965 }
 966
 967 void GLAPIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 968 {
 969    DISPATCH_SETUP;
 970    DISPATCH(ColorMask)(red, green, blue, alpha);
 971 }
 972
 973 void GLAPIENTRY glColorMaterial(GLenum face, GLenum mode)
 974 {
 975    DISPATCH_SETUP;
 976    DISPATCH(ColorMaterial)(face, mode);
 977 }
 978
 979 void GLAPIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 980 {
 981    DISPATCH_SETUP;
 982    DISPATCH(CopyPixels)(x, y, width, height, type);
 983 }
 984
 985 void GLAPIENTRY glCullFace(GLenum mode)
 986 {
 987    DISPATCH_SETUP;
 988    DISPATCH(CullFace)(mode);
 989 }
 990
 991 void GLAPIENTRY glDepthFunc(GLenum func)
 992 {
 993    DISPATCH_SETUP;
 994    DISPATCH(DepthFunc)(func);
 995 }
 996
 997 void GLAPIENTRY glDepthMask(GLboolean flag)
 998 {
 999    DISPATCH_SETUP;
1000    DISPATCH(DepthMask)(flag);
1001 }
1002
1003 void GLAPIENTRY glDepthRange(GLclampd nearVal, GLclampd farVal)
1004 {
1005    DISPATCH_SETUP;
1006    DISPATCH(DepthRange)(nearVal, farVal);
1007 }
1008
1009 void GLAPIENTRY glDeleteLists(GLuint list, GLsizei range)
1010 {
1011    DISPATCH_SETUP;
1012    DISPATCH(DeleteLists)(list, range);
1013 }
1014
1015 void GLAPIENTRY glDisable(GLenum cap)
1016 {
1017    DISPATCH_SETUP;
1018    DISPATCH(Disable)(cap);
1019 }
1020
1021 void GLAPIENTRY glDrawBuffer(GLenum mode)
1022 {
1023    DISPATCH_SETUP;
1024    DISPATCH(DrawBuffer)(mode);
1025 }
1026
1027 void GLAPIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
1028 {
1029    DISPATCH_SETUP;
1030    DISPATCH(DrawElements)(mode, count, type, indices);
1031 }
1032
1033 void GLAPIENTRY glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
1034 {
1035    DISPATCH_SETUP;
1036    DISPATCH(DrawPixels)(width, height, format, type, pixels);
1037 }
1038
1039 void GLAPIENTRY glEnable(GLenum mode)
1040 {
1041    DISPATCH_SETUP;
1042    DISPATCH(Enable)(mode);
1043 }
1044
1045 void GLAPIENTRY glEnd(void)
1046 {
1047    DISPATCH_SETUP;
1048    DISPATCH(End)();
1049 }
1050
1051 void GLAPIENTRY glEndList(void)
1052 {
1053    DISPATCH_SETUP;
1054    DISPATCH(EndList)();
1055 }
1056
1057 void GLAPIENTRY glEvalCoord1d(GLdouble u)
1058 {
1059    DISPATCH_SETUP;
1060    DISPATCH(EvalCoord1d)(u);
1061 }
1062
1063 void GLAPIENTRY glEvalCoord1f(GLfloat u)
1064 {
1065    DISPATCH_SETUP;
1066    DISPATCH(EvalCoord1f)(u);
1067 }
1068
1069 void GLAPIENTRY glEvalCoord1dv(const GLdouble *u)
1070 {
1071    DISPATCH_SETUP;
1072    DISPATCH(EvalCoord1dv)(u);
1073 }
1074
1075 void GLAPIENTRY glEvalCoord1fv(const GLfloat *u)
1076 {
1077    DISPATCH_SETUP;
1078    DISPATCH(EvalCoord1fv)(u);
1079 }
1080
1081 void GLAPIENTRY glEvalCoord2d(GLdouble u, GLdouble v)
1082 {
1083    DISPATCH_SETUP;
1084    DISPATCH(EvalCoord2d)(u, v);
1085 }
1086
1087 void GLAPIENTRY glEvalCoord2f(GLfloat u, GLfloat v)
1088 {
1089    DISPATCH_SETUP;
1090    DISPATCH(EvalCoord2f)(u, v);
1091 }
1092
1093 void GLAPIENTRY glEvalCoord2dv(const GLdouble *u)
1094 {
1095    DISPATCH_SETUP;
1096    DISPATCH(EvalCoord2dv)(u);
1097 }
1098
1099 void GLAPIENTRY glEvalCoord2fv(const GLfloat *u)
1100 {
1101    DISPATCH_SETUP;
1102    DISPATCH(EvalCoord2fv)(u);
1103 }
1104
1105 void GLAPIENTRY glEvalPoint1(GLint i)
1106 {
1107    DISPATCH_SETUP;
1108    DISPATCH(EvalPoint1)(i);
1109 }
1110
1111 void GLAPIENTRY glEvalPoint2(GLint i, GLint j)
1112 {
1113    DISPATCH_SETUP;
1114    DISPATCH(EvalPoint2)(i, j);
1115 }
1116
1117 void GLAPIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2)
1118 {
1119    DISPATCH_SETUP;
1120    DISPATCH(EvalMesh1)(mode, i1, i2);
1121 }
1122
1123 void GLAPIENTRY glEdgeFlag(GLboolean flag)
1124 {
1125    DISPATCH_SETUP;
1126    DISPATCH(EdgeFlag)(flag);
1127 }
1128
1129 void GLAPIENTRY glEdgeFlagv(const GLboolean *flag)
1130 {
1131    DISPATCH_SETUP;
1132    DISPATCH(EdgeFlagv)(flag);
1133 }
1134
1135 void GLAPIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1136 {
1137    DISPATCH_SETUP;
1138    DISPATCH(EvalMesh2)(mode, i1, i2, j1, j2);
1139 }
1140
1141 void GLAPIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
1142 {
1143    DISPATCH_SETUP;
1144    DISPATCH(FeedbackBuffer)(size, type, buffer);
1145 }
1146
1147 void GLAPIENTRY glFinish(void)
1148 {
1149    DISPATCH_SETUP;
1150    DISPATCH(Finish)();
1151 }
1152
1153 void GLAPIENTRY glFlush(void)
1154 {
1155    DISPATCH_SETUP;
1156    DISPATCH(Flush)();
1157 }
1158
1159 void GLAPIENTRY glFogf(GLenum pname, GLfloat param)
1160 {
1161    DISPATCH_SETUP;
1162    DISPATCH(Fogf)(pname, param);
1163 }
1164
1165 void GLAPIENTRY glFogi(GLenum pname, GLint param)
1166 {
1167    DISPATCH_SETUP;
1168    DISPATCH(Fogi)(pname, param);
1169 }
1170
1171 void GLAPIENTRY glFogfv(GLenum pname, const GLfloat *params)
1172 {
1173    DISPATCH_SETUP;
1174    DISPATCH(Fogfv)(pname, params);
1175 }
1176
1177 void GLAPIENTRY glFogiv(GLenum pname, const GLint *params)
1178 {
1179    DISPATCH_SETUP;
1180    DISPATCH(Fogiv)(pname, params);
1181 }
1182
1183 void GLAPIENTRY glFrontFace(GLenum mode)
1184 {
1185    DISPATCH_SETUP;
1186    DISPATCH(FrontFace)(mode);
1187 }
1188
1189 void GLAPIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
1190 {
1191    DISPATCH_SETUP;
1192    DISPATCH(Frustum)(left, right, bottom, top, nearval, farval);
1193 }
1194
1195 GLuint GLAPIENTRY glGenLists(GLsizei range)
1196 {
1197    DISPATCH_SETUP;
1198    return DISPATCH(GenLists)(range);
1199 }
1200
1201 void GLAPIENTRY glGetBooleanv(GLenum pname, GLboolean *params)
1202 {
1203    DISPATCH_SETUP;
1204    DISPATCH(GetBooleanv)(pname, params);
1205 }
1206
1207 void GLAPIENTRY glGetClipPlane(GLenum plane, GLdouble *equation)
1208 {
1209    DISPATCH_SETUP;
1210    DISPATCH(GetClipPlane)(plane, equation);
1211 }
1212
1213 void GLAPIENTRY glGetDoublev(GLenum pname, GLdouble *params)
1214 {
1215    DISPATCH_SETUP;
1216    DISPATCH(GetDoublev)(pname, params);
1217 }
1218
1219 GLenum GLAPIENTRY glGetError(void)
1220 {
1221    DISPATCH_SETUP;
1222    return DISPATCH(GetError)();
1223 }
1224
1225 void GLAPIENTRY glGetFloatv(GLenum pname, GLfloat *params)
1226 {
1227    DISPATCH_SETUP;
1228    DISPATCH(GetFloatv)(pname, params);
1229 }
1230
1231 void GLAPIENTRY glGetIntegerv(GLenum pname, GLint *params)
1232 {
1233    DISPATCH_SETUP;
1234    DISPATCH(GetIntegerv)(pname, params);
1235 }
1236
1237 void GLAPIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
1238 {
1239    DISPATCH_SETUP;
1240    DISPATCH(GetLightfv)(light, pname, params);
1241 }
1242
1243 void GLAPIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params)
1244 {
1245    DISPATCH_SETUP;
1246    DISPATCH(GetLightiv)(light, pname, params);
1247 }
1248
1249 void GLAPIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v)
1250 {
1251    DISPATCH_SETUP;
1252    DISPATCH(GetMapdv)(target, query, v);
1253 }
1254
1255 void GLAPIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v)
1256 {
1257    DISPATCH_SETUP;
1258    DISPATCH(GetMapfv)(target, query, v);
1259 }
1260
1261 void GLAPIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v)
1262 {
1263    DISPATCH_SETUP;
1264    DISPATCH(GetMapiv)(target, query, v);
1265 }
1266
1267 void GLAPIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
1268 {
1269    DISPATCH_SETUP;
1270    DISPATCH(GetMaterialfv)(face, pname, params);
1271 }
1272
1273 void GLAPIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
1274 {
1275    DISPATCH_SETUP;
1276    DISPATCH(GetMaterialiv)(face, pname, params);
1277 }
1278
1279 void GLAPIENTRY glGetPixelMapfv(GLenum map, GLfloat *values)
1280 {
1281    DISPATCH_SETUP;
1282    DISPATCH(GetPixelMapfv)(map, values);
1283 }
1284
1285 void GLAPIENTRY glGetPixelMapuiv(GLenum map, GLuint *values)
1286 {
1287    DISPATCH_SETUP;
1288    DISPATCH(GetPixelMapuiv)(map, values);
1289 }
1290
1291 void GLAPIENTRY glGetPixelMapusv(GLenum map, GLushort *values)
1292 {
1293    DISPATCH_SETUP;
1294    DISPATCH(GetPixelMapusv)(map, values);
1295 }
1296
1297 void GLAPIENTRY glGetPolygonStipple(GLubyte *mask)
1298 {
1299    DISPATCH_SETUP;
1300    DISPATCH(GetPolygonStipple)(mask);
1301 }
1302
1303 const GLubyte * GLAPIENTRY glGetString(GLenum name)
1304 {
1305    DISPATCH_SETUP;
1306    return DISPATCH(GetString)(name);
1307 }
1308
1309 void GLAPIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
1310 {
1311    DISPATCH_SETUP;
1312    DISPATCH(GetTexEnvfv)(target, pname, params);
1313 }
1314
1315 void GLAPIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
1316 {
1317    DISPATCH_SETUP;
1318    DISPATCH(GetTexEnviv)(target, pname, params);
1319 }
1320
1321 void GLAPIENTRY glGetTexGeniv(GLenum target, GLenum pname, GLint *params)
1322 {
1323    DISPATCH_SETUP;
1324    DISPATCH(GetTexGeniv)(target, pname, params);
1325 }
1326
1327 void GLAPIENTRY glGetTexGendv(GLenum target, GLenum pname, GLdouble *params)
1328 {
1329    DISPATCH_SETUP;
1330    DISPATCH(GetTexGendv)(target, pname, params);
1331 }
1332
1333 void GLAPIENTRY glGetTexGenfv(GLenum target, GLenum pname, GLfloat *params)
1334 {
1335    DISPATCH_SETUP;
1336    DISPATCH(GetTexGenfv)(target, pname, params);
1337 }
1338
1339 void GLAPIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
1340 {
1341    DISPATCH_SETUP;
1342    DISPATCH(GetTexImage)(target, level, format, type, pixels);
1343 }
1344
1345 void GLAPIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
1346 {
1347    DISPATCH_SETUP;
1348    DISPATCH(GetTexLevelParameterfv)(target, level, pname, params);
1349 }
1350
1351 void GLAPIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
1352 {
1353    DISPATCH_SETUP;
1354    DISPATCH(GetTexLevelParameteriv)(target, level, pname, params);
1355 }
1356
1357 void GLAPIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
1358 {
1359    DISPATCH_SETUP;
1360    DISPATCH(GetTexParameterfv)(target, pname, params);
1361 }
1362
1363 void GLAPIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
1364 {
1365    DISPATCH_SETUP;
1366    DISPATCH(GetTexParameteriv)(target, pname, params);
1367 }
1368
1369 void GLAPIENTRY glHint(GLenum target, GLenum mode)
1370 {
1371    DISPATCH_SETUP;
1372    DISPATCH(Hint)(target, mode);
1373 }
1374
1375 void GLAPIENTRY glIndexd(GLdouble c)
1376 {
1377    DISPATCH_SETUP;
1378    DISPATCH(Indexd)(c);
1379 }
1380
1381 void GLAPIENTRY glIndexdv(const GLdouble *c)
1382 {
1383    DISPATCH_SETUP;
1384    DISPATCH(Indexdv)(c);
1385 }
1386
1387 void GLAPIENTRY glIndexf(GLfloat c)
1388 {
1389    DISPATCH_SETUP;
1390    DISPATCH(Indexf)(c);
1391 }
1392
1393 void GLAPIENTRY glIndexfv(const GLfloat *c)
1394 {
1395    DISPATCH_SETUP;
1396    DISPATCH(Indexfv)(c);
1397 }
1398
1399 void GLAPIENTRY glIndexi(GLint c)
1400 {
1401    DISPATCH_SETUP;
1402    DISPATCH(Indexi)(c);
1403 }
1404
1405 void GLAPIENTRY glIndexiv(const GLint *c)
1406 {
1407    DISPATCH_SETUP;
1408    DISPATCH(Indexiv)(c);
1409 }
1410
1411 void GLAPIENTRY glIndexs(GLshort c)
1412 {
1413    DISPATCH_SETUP;
1414    DISPATCH(Indexs)(c);
1415 }
1416
1417 void GLAPIENTRY glIndexsv(const GLshort *c)
1418 {
1419    DISPATCH_SETUP;
1420    DISPATCH(Indexsv)(c);
1421 }
1422
1423 void GLAPIENTRY glIndexub(GLubyte c)
1424 {
1425    DISPATCH_SETUP;
1426    DISPATCH(Indexub)(c);
1427 }
1428
1429 void GLAPIENTRY glIndexubv(const GLubyte *c)
1430 {
1431    DISPATCH_SETUP;
1432    DISPATCH(Indexubv)(c);
1433 }
1434
1435 void GLAPIENTRY glIndexMask(GLuint mask)
1436 {
1437    DISPATCH_SETUP;
1438    DISPATCH(IndexMask)(mask);
1439 }
1440
1441 void GLAPIENTRY glInitNames(void)
1442 {
1443    DISPATCH_SETUP;
1444    DISPATCH(InitNames)();
1445 }
1446
1447 void GLAPIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
1448 {
1449    DISPATCH_SETUP;
1450    DISPATCH(InterleavedArrays)(format, stride, pointer);
1451 }
1452
1453 GLboolean GLAPIENTRY glIsEnabled(GLenum cap)
1454 {
1455    DISPATCH_SETUP;
1456    return DISPATCH(IsEnabled)(cap);
1457 }
1458
1459 GLboolean GLAPIENTRY glIsList(GLuint list)
1460 {
1461    DISPATCH_SETUP;
1462    return DISPATCH(IsList)(list);
1463 }
1464
1465 GLboolean GLAPIENTRY glIsTexture(GLuint texture)
1466 {
1467    DISPATCH_SETUP;
1468    return DISPATCH(IsTexture)(texture);
1469 }
1470
1471 void GLAPIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)
1472 {
1473    DISPATCH_SETUP;
1474    DISPATCH(Lightf)(light, pname, param);
1475 }
1476
1477 void GLAPIENTRY glLighti(GLenum light, GLenum pname, GLint param)
1478 {
1479    DISPATCH_SETUP;
1480    DISPATCH(Lighti)(light, pname, param);
1481 }
1482
1483 void GLAPIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)
1484 {
1485    DISPATCH_SETUP;
1486    DISPATCH(Lightfv)(light, pname, params);
1487 }
1488
1489 void GLAPIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params)
1490 {
1491    DISPATCH_SETUP;
1492    DISPATCH(Lightiv)(light, pname, params);
1493 }
1494
1495 void GLAPIENTRY glLightModelf(GLenum pname, GLfloat param)
1496 {
1497    DISPATCH_SETUP;
1498    DISPATCH(LightModelf)(pname, param);
1499 }
1500
1501 void GLAPIENTRY glLightModeli(GLenum pname, GLint param)
1502 {
1503    DISPATCH_SETUP;
1504    DISPATCH(LightModeli)(pname, param);
1505 }
1506
1507 void GLAPIENTRY glLightModelfv(GLenum pname, const GLfloat *params)
1508 {
1509    DISPATCH_SETUP;
1510    DISPATCH(LightModelfv)(pname, params);
1511 }
1512
1513 void GLAPIENTRY glLightModeliv(GLenum pname, const GLint *params)
1514 {
1515    DISPATCH_SETUP;
1516    DISPATCH(LightModeliv)(pname, params);
1517 }
1518
1519 void GLAPIENTRY glLineWidth(GLfloat width)
1520 {
1521    DISPATCH_SETUP;
1522    DISPATCH(LineWidth)(width);
1523 }
1524
1525 void GLAPIENTRY glLineStipple(GLint factor, GLushort pattern)
1526 {
1527    DISPATCH_SETUP;
1528    DISPATCH(LineStipple)(factor, pattern);
1529 }
1530
1531 void GLAPIENTRY glListBase(GLuint base)
1532 {
1533    DISPATCH_SETUP;
1534    DISPATCH(ListBase)(base);
1535 }
1536
1537 void GLAPIENTRY glLoadIdentity(void)
1538 {
1539    DISPATCH_SETUP;
1540    DISPATCH(LoadIdentity)();
1541 }
1542
1543 void GLAPIENTRY glLoadMatrixd(const GLdouble *m)
1544 {
1545    DISPATCH_SETUP;
1546    DISPATCH(LoadMatrixd)(m);
1547 }
1548
1549 void GLAPIENTRY glLoadMatrixf(const GLfloat *m)
1550 {
1551    DISPATCH_SETUP;
1552    DISPATCH(LoadMatrixf)(m);
1553 }
1554
1555 void GLAPIENTRY glLoadName(GLuint name)
1556 {
1557    DISPATCH_SETUP;
1558    DISPATCH(LoadName)(name);
1559 }
1560
1561 void GLAPIENTRY glLogicOp(GLenum opcode)
1562 {
1563    DISPATCH_SETUP;
1564    DISPATCH(LogicOp)(opcode);
1565 }
1566
1567 void GLAPIENTRY glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
1568 {
1569    DISPATCH_SETUP;
1570    DISPATCH(Map1d)(target, u1, u2, stride, order, points);
1571 }
1572
1573 void GLAPIENTRY glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
1574 {
1575    DISPATCH_SETUP;
1576    DISPATCH(Map1f)(target, u1, u2, stride, order, points);
1577 }
1578
1579 void GLAPIENTRY glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
1580 {
1581    DISPATCH_SETUP;
1582    DISPATCH(Map2d)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
1583 }
1584
1585 void GLAPIENTRY glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
1586 {
1587    DISPATCH_SETUP;
1588    DISPATCH(Map2f)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
1589 }
1590
1591 void GLAPIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
1592 {
1593    DISPATCH_SETUP;
1594    DISPATCH(MapGrid1d)(un, u1, u2);
1595 }
1596
1597 void GLAPIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
1598 {
1599    DISPATCH_SETUP;
1600    DISPATCH(MapGrid1f)(un, u1, u2);
1601 }
1602
1603 void GLAPIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
1604 {
1605    DISPATCH_SETUP;
1606    DISPATCH(MapGrid2d)(un, u1, u2, vn, v1, v2);
1607 }
1608
1609 void GLAPIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
1610 {
1611    DISPATCH_SETUP;
1612    DISPATCH(MapGrid2f)(un, u1, u2, vn, v1, v2);
1613 }
1614
1615 void GLAPIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)
1616 {
1617    DISPATCH_SETUP;
1618    DISPATCH(Materialf)(face, pname, param);
1619 }
1620
1621 void GLAPIENTRY glMateriali(GLenum face, GLenum pname, GLint param)
1622 {
1623    DISPATCH_SETUP;
1624    DISPATCH(Materiali)(face, pname, param);
1625 }
1626
1627 void GLAPIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
1628 {
1629    DISPATCH_SETUP;
1630    DISPATCH(Materialfv)(face, pname, params);
1631 }
1632
1633 void GLAPIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params)
1634 {
1635    DISPATCH_SETUP;
1636    DISPATCH(Materialiv)(face, pname, params);
1637 }
1638
1639 void GLAPIENTRY glMatrixMode(GLenum mode)
1640 {
1641    DISPATCH_SETUP;
1642    DISPATCH(MatrixMode)(mode);
1643 }
1644
1645 void GLAPIENTRY glMultMatrixd(const GLdouble *m)
1646 {
1647    DISPATCH_SETUP;
1648    DISPATCH(MultMatrixd)(m);
1649 }
1650
1651 void GLAPIENTRY glMultMatrixf(const GLfloat *m)
1652 {
1653    DISPATCH_SETUP;
1654    DISPATCH(MultMatrixf)(m);
1655 }
1656
1657 void GLAPIENTRY glNewList(GLuint list, GLenum mode)
1658 {
1659    DISPATCH_SETUP;
1660    DISPATCH(NewList)(list, mode);
1661 }
1662
1663 void GLAPIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
1664 {
1665    DISPATCH_SETUP;
1666    DISPATCH(Normal3b)(nx, ny, nz);
1667 }
1668
1669 void GLAPIENTRY glNormal3bv(const GLbyte *v)
1670 {
1671    DISPATCH_SETUP;
1672    DISPATCH(Normal3bv)(v);
1673 }
1674
1675 void GLAPIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
1676 {
1677    DISPATCH_SETUP;
1678    DISPATCH(Normal3d)(nx, ny, nz);
1679 }
1680
1681 void GLAPIENTRY glNormal3dv(const GLdouble *v)
1682 {
1683    DISPATCH_SETUP;
1684    DISPATCH(Normal3dv)(v);
1685 }
1686
1687 void GLAPIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1688 {
1689    DISPATCH_SETUP;
1690    DISPATCH(Normal3f)(nx, ny, nz);
1691 }
1692
1693 void GLAPIENTRY glNormal3fv(const GLfloat *v)
1694 {
1695    DISPATCH_SETUP;
1696    DISPATCH(Normal3fv)(v);
1697 }
1698
1699 void GLAPIENTRY glNormal3i(GLint nx, GLint ny, GLint nz)
1700 {
1701    DISPATCH_SETUP;
1702    DISPATCH(Normal3i)(nx, ny, nz);
1703 }
1704
1705 void GLAPIENTRY glNormal3iv(const GLint *v)
1706 {
1707    DISPATCH_SETUP;
1708    DISPATCH(Normal3iv)(v);
1709 }
1710
1711 void GLAPIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz)
1712 {
1713    DISPATCH_SETUP;
1714    DISPATCH(Normal3s)(nx, ny, nz);
1715 }
1716
1717 void GLAPIENTRY glNormal3sv(const GLshort *v)
1718 {
1719    DISPATCH_SETUP;
1720    DISPATCH(Normal3sv)(v);
1721 }
1722
1723 void GLAPIENTRY glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
1724 {
1725    DISPATCH_SETUP;
1726    DISPATCH(Ortho)(left, right, bottom, top, nearval, farval);
1727 }
1728
1729 void GLAPIENTRY glPassThrough(GLfloat token)
1730 {
1731    DISPATCH_SETUP;
1732    DISPATCH(PassThrough)(token);
1733 }
1734
1735 void GLAPIENTRY glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
1736 {
1737    DISPATCH_SETUP;
1738    DISPATCH(PixelMapfv)(map, mapsize, values);
1739 }
1740
1741 void GLAPIENTRY glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
1742 {
1743    DISPATCH_SETUP;
1744    DISPATCH(PixelMapuiv)(map, mapsize, values);
1745 }
1746
1747 void GLAPIENTRY glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
1748 {
1749    DISPATCH_SETUP;
1750    DISPATCH(PixelMapusv)(map, mapsize, values);
1751 }
1752
1753 void GLAPIENTRY glPixelStoref(GLenum pname, GLfloat param)
1754 {
1755    DISPATCH_SETUP;
1756    DISPATCH(PixelStoref)(pname, param);
1757 }
1758
1759 void GLAPIENTRY glPixelStorei(GLenum pname, GLint param)
1760 {
1761    DISPATCH_SETUP;
1762    DISPATCH(PixelStorei)(pname, param);
1763 }
1764
1765 void GLAPIENTRY glPixelTransferf(GLenum pname, GLfloat param)
1766 {
1767    DISPATCH_SETUP;
1768    DISPATCH(PixelTransferf)(pname, param);
1769 }
1770
1771 void GLAPIENTRY glPixelTransferi(GLenum pname, GLint param)
1772 {
1773    DISPATCH_SETUP;
1774    DISPATCH(PixelTransferi)(pname, param);
1775 }
1776
1777 void GLAPIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor)
1778 {
1779    DISPATCH_SETUP;
1780    DISPATCH(PixelZoom)(xfactor, yfactor);
1781 }
1782
1783 void GLAPIENTRY glPointSize(GLfloat size)
1784 {
1785    DISPATCH_SETUP;
1786    DISPATCH(PointSize)(size);
1787 }
1788
1789 void GLAPIENTRY glPolygonMode(GLenum face, GLenum mode)
1790 {
1791    DISPATCH_SETUP;
1792    DISPATCH(PolygonMode)(face, mode);
1793 }
1794
1795 void GLAPIENTRY glPolygonStipple(const GLubyte *pattern)
1796 {
1797    DISPATCH_SETUP;
1798    DISPATCH(PolygonStipple)(pattern);
1799 }
1800
1801 void GLAPIENTRY glPopAttrib(void)
1802 {
1803    DISPATCH_SETUP;
1804    DISPATCH(PopAttrib)();
1805 }
1806
1807 void GLAPIENTRY glPopMatrix(void)
1808 {
1809    DISPATCH_SETUP;
1810    DISPATCH(PopMatrix)();
1811 }
1812
1813 void GLAPIENTRY glPopName(void)
1814 {
1815    DISPATCH_SETUP;
1816    DISPATCH(PopName)();
1817 }
1818
1819 void GLAPIENTRY glPushAttrib(GLbitfield mask)
1820 {
1821    DISPATCH_SETUP;
1822    DISPATCH(PushAttrib)(mask);
1823 }
1824
1825 void GLAPIENTRY glPushMatrix(void)
1826 {
1827    DISPATCH_SETUP;
1828    DISPATCH(PushMatrix)();
1829 }
1830
1831 void GLAPIENTRY glPushName(GLuint name)
1832 {
1833    DISPATCH_SETUP;
1834    DISPATCH(PushName)(name);
1835 }
1836
1837 void GLAPIENTRY glRasterPos2d(GLdouble x, GLdouble y)
1838 {
1839    DISPATCH_SETUP;
1840    DISPATCH(RasterPos2d)(x, y);
1841 }
1842
1843 void GLAPIENTRY glRasterPos2f(GLfloat x, GLfloat y)
1844 {
1845    DISPATCH_SETUP;
1846    DISPATCH(RasterPos2f)(x, y);
1847 }
1848
1849 void GLAPIENTRY glRasterPos2i(GLint x, GLint y)
1850 {
1851    DISPATCH_SETUP;
1852    DISPATCH(RasterPos2i)(x, y);
1853 }
1854
1855 void GLAPIENTRY glRasterPos2s(GLshort x, GLshort y)
1856 {
1857    DISPATCH_SETUP;
1858    DISPATCH(RasterPos2s)(x, y);
1859 }
1860
1861 void GLAPIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1862 {
1863    DISPATCH_SETUP;
1864    DISPATCH(RasterPos3d)(x, y, z);
1865 }
1866
1867 void GLAPIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1868 {
1869    DISPATCH_SETUP;
1870    DISPATCH(RasterPos3f)(x, y, z);
1871 }
1872
1873 void GLAPIENTRY glRasterPos3i(GLint x, GLint y, GLint z)
1874 {
1875    DISPATCH_SETUP;
1876    DISPATCH(RasterPos3i)(x, y, z);
1877 }
1878
1879 void GLAPIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z)
1880 {
1881    DISPATCH_SETUP;
1882    DISPATCH(RasterPos3s)(x, y, z);
1883 }
1884
1885 void GLAPIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1886 {
1887    DISPATCH_SETUP;
1888    DISPATCH(RasterPos4d)(x, y, z, w);
1889 }
1890
1891 void GLAPIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1892 {
1893    DISPATCH_SETUP;
1894    DISPATCH(RasterPos4f)(x, y, z, w);
1895 }
1896
1897 void GLAPIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1898 {
1899    DISPATCH_SETUP;
1900    DISPATCH(RasterPos4i)(x, y, z, w);
1901 }
1902
1903 void GLAPIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1904 {
1905    DISPATCH_SETUP;
1906    DISPATCH(RasterPos4s)(x, y, z, w);
1907 }
1908
1909 void GLAPIENTRY glRasterPos2dv(const GLdouble *v)
1910 {
1911    DISPATCH_SETUP;
1912    DISPATCH(RasterPos2dv)(v);
1913 }
1914
1915 void GLAPIENTRY glRasterPos2fv(const GLfloat *v)
1916 {
1917    DISPATCH_SETUP;
1918    DISPATCH(RasterPos2fv)(v);
1919 }
1920
1921 void GLAPIENTRY glRasterPos2iv(const GLint *v)
1922 {
1923    DISPATCH_SETUP;
1924    DISPATCH(RasterPos2iv)(v);
1925 }
1926
1927 void GLAPIENTRY glRasterPos2sv(const GLshort *v)
1928 {
1929    DISPATCH_SETUP;
1930    DISPATCH(RasterPos2sv)(v);
1931 }
1932
1933 void GLAPIENTRY glRasterPos3dv(const GLdouble *v)
1934 {
1935    DISPATCH_SETUP;
1936    DISPATCH(RasterPos3dv)(v);
1937 }
1938
1939 void GLAPIENTRY glRasterPos3fv(const GLfloat *v)
1940 {
1941    DISPATCH_SETUP;
1942    DISPATCH(RasterPos3fv)(v);
1943 }
1944
1945 void GLAPIENTRY glRasterPos3iv(const GLint *v)
1946 {
1947    DISPATCH_SETUP;
1948    DISPATCH(RasterPos3iv)(v);
1949 }
1950
1951 void GLAPIENTRY glRasterPos3sv(const GLshort *v)
1952 {
1953    DISPATCH_SETUP;
1954    DISPATCH(RasterPos3sv)(v);
1955 }
1956
1957 void GLAPIENTRY glRasterPos4dv(const GLdouble *v)
1958 {
1959    DISPATCH_SETUP;
1960    DISPATCH(RasterPos4dv)(v);
1961 }
1962
1963 void GLAPIENTRY glRasterPos4fv(const GLfloat *v)
1964 {
1965    DISPATCH_SETUP;
1966    DISPATCH(RasterPos4fv)(v);
1967 }
1968
1969 void GLAPIENTRY glRasterPos4iv(const GLint *v)
1970 {
1971    DISPATCH_SETUP;
1972    DISPATCH(RasterPos4iv)(v);
1973 }
1974
1975 void GLAPIENTRY glRasterPos4sv(const GLshort *v)
1976 {
1977    DISPATCH_SETUP;
1978    DISPATCH(RasterPos4sv)(v);
1979 }
1980
1981 void GLAPIENTRY glReadBuffer(GLenum mode)
1982 {
1983    DISPATCH_SETUP;
1984    DISPATCH(ReadBuffer)(mode);
1985 }
1986
1987 void GLAPIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
1988 {
1989    DISPATCH_SETUP;
1990    DISPATCH(ReadPixels)(x, y, width, height, format, type, pixels);
1991 }
1992
1993 void GLAPIENTRY glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1994 {
1995    DISPATCH_SETUP;
1996    DISPATCH(Rectd)(x1, y1, x2, y2);
1997 }
1998
1999 void GLAPIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2)
2000 {
2001    DISPATCH_SETUP;
2002    DISPATCH(Rectdv)(v1, v2);
2003 }
2004
2005 void GLAPIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
2006 {
2007    DISPATCH_SETUP;
2008    DISPATCH(Rectf)(x1, y1, x2, y2);
2009 }
2010
2011 void GLAPIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2)
2012 {
2013    DISPATCH_SETUP;
2014    DISPATCH(Rectfv)(v1, v2);
2015 }
2016
2017 void GLAPIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
2018 {
2019    DISPATCH_SETUP;
2020    DISPATCH(Recti)(x1, y1, x2, y2);
2021 }
2022
2023 void GLAPIENTRY glRectiv(const GLint *v1, const GLint *v2)
2024 {
2025    DISPATCH_SETUP;
2026    DISPATCH(Rectiv)(v1, v2);
2027 }
2028
2029 void GLAPIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
2030 {
2031    DISPATCH_SETUP;
2032    DISPATCH(Rects)(x1, y1, x2, y2);
2033 }
2034
2035 void GLAPIENTRY glRectsv(const GLshort *v1, const GLshort *v2)
2036 {
2037    DISPATCH_SETUP;
2038    DISPATCH(Rectsv)(v1, v2);
2039 }
2040
2041 GLint GLAPIENTRY glRenderMode(GLenum mode)
2042 {
2043    DISPATCH_SETUP;
2044    return DISPATCH(RenderMode)(mode);
2045 }
2046
2047 void GLAPIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
2048 {
2049    DISPATCH_SETUP;
2050    DISPATCH(Rotated)(angle, x, y, z);
2051 }
2052
2053 void GLAPIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
2054 {
2055    DISPATCH_SETUP;
2056    DISPATCH(Rotatef)(angle, x, y, z);
2057 }
2058
2059 void GLAPIENTRY glSelectBuffer(GLsizei size, GLuint *buffer)
2060 {
2061    DISPATCH_SETUP;
2062    DISPATCH(SelectBuffer)(size, buffer);
2063 }
2064
2065 void GLAPIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z)
2066 {
2067    DISPATCH_SETUP;
2068    DISPATCH(Scaled)(x, y, z);
2069 }
2070
2071 void GLAPIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
2072 {
2073    DISPATCH_SETUP;
2074    DISPATCH(Scalef)(x, y, z);
2075 }
2076
2077 void GLAPIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2078 {
2079    DISPATCH_SETUP;
2080    DISPATCH(Scissor)(x, y, width, height);
2081 }
2082
2083 void GLAPIENTRY glShadeModel(GLenum mode)
2084 {
2085    DISPATCH_SETUP;
2086    DISPATCH(ShadeModel)(mode);
2087 }
2088
2089 void GLAPIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
2090 {
2091    DISPATCH_SETUP;
2092    DISPATCH(StencilFunc)(func, ref, mask);
2093 }
2094
2095 void GLAPIENTRY glStencilMask(GLuint mask)
2096 {
2097    DISPATCH_SETUP;
2098    DISPATCH(StencilMask)(mask);
2099 }
2100
2101 void GLAPIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2102 {
2103    DISPATCH_SETUP;
2104    DISPATCH(StencilOp)(fail, zfail, zpass);
2105 }
2106
2107 void GLAPIENTRY glTexCoord1d(GLdouble s)
2108 {
2109    DISPATCH_SETUP;
2110    DISPATCH(TexCoord1d)(s);
2111 }
2112
2113 void GLAPIENTRY glTexCoord1f(GLfloat s)
2114 {
2115    DISPATCH_SETUP;
2116    DISPATCH(TexCoord1f)(s);
2117 }
2118
2119 void GLAPIENTRY glTexCoord1i(GLint s)
2120 {
2121    DISPATCH_SETUP;
2122    DISPATCH(TexCoord1i)(s);
2123 }
2124
2125 void GLAPIENTRY glTexCoord1s(GLshort s)
2126 {
2127    DISPATCH_SETUP;
2128    DISPATCH(TexCoord1s)(s);
2129 }
2130
2131 void GLAPIENTRY glTexCoord2d(GLdouble s, GLdouble t)
2132 {
2133    DISPATCH_SETUP;
2134    DISPATCH(TexCoord2d)(s, t);
2135 }
2136
2137 void GLAPIENTRY glTexCoord2f(GLfloat s, GLfloat t)
2138 {
2139    DISPATCH_SETUP;
2140    DISPATCH(TexCoord2f)(s, t);
2141 }
2142
2143 void GLAPIENTRY glTexCoord2s(GLshort s, GLshort t)
2144 {
2145    DISPATCH_SETUP;
2146    DISPATCH(TexCoord2s)(s, t);
2147 }
2148
2149 void GLAPIENTRY glTexCoord2i(GLint s, GLint t)
2150 {
2151    DISPATCH_SETUP;
2152    DISPATCH(TexCoord2i)(s, t);
2153 }
2154
2155 void GLAPIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
2156 {
2157    DISPATCH_SETUP;
2158    DISPATCH(TexCoord3d)(s, t, r);
2159 }
2160
2161 void GLAPIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
2162 {
2163    DISPATCH_SETUP;
2164    DISPATCH(TexCoord3f)(s, t, r);
2165 }
2166
2167 void GLAPIENTRY glTexCoord3i(GLint s, GLint t, GLint r)
2168 {
2169    DISPATCH_SETUP;
2170    DISPATCH(TexCoord3i)(s, t, r);
2171 }
2172
2173 void GLAPIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r)
2174 {
2175    DISPATCH_SETUP;
2176    DISPATCH(TexCoord3s)(s, t, r);
2177 }
2178
2179 void GLAPIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
2180 {
2181    DISPATCH_SETUP;
2182    DISPATCH(TexCoord4d)(s, t, r, q);
2183 }
2184
2185 void GLAPIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
2186 {
2187    DISPATCH_SETUP;
2188    DISPATCH(TexCoord4f)(s, t, r, q);
2189 }
2190
2191 void GLAPIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
2192 {
2193    DISPATCH_SETUP;
2194    DISPATCH(TexCoord4i)(s, t, r, q);
2195 }
2196
2197 void GLAPIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
2198 {
2199    DISPATCH_SETUP;
2200    DISPATCH(TexCoord4s)(s, t, r, q);
2201 }
2202
2203 void GLAPIENTRY glTexCoord1dv(const GLdouble *v)
2204 {
2205    DISPATCH_SETUP;
2206    DISPATCH(TexCoord1dv)(v);
2207 }
2208
2209 void GLAPIENTRY glTexCoord1fv(const GLfloat *v)
2210 {
2211    DISPATCH_SETUP;
2212    DISPATCH(TexCoord1fv)(v);
2213 }
2214
2215 void GLAPIENTRY glTexCoord1iv(const GLint *v)
2216 {
2217    DISPATCH_SETUP;
2218    DISPATCH(TexCoord1iv)(v);
2219 }
2220
2221 void GLAPIENTRY glTexCoord1sv(const GLshort *v)
2222 {
2223    DISPATCH_SETUP;
2224    DISPATCH(TexCoord1sv)(v);
2225 }
2226
2227 void GLAPIENTRY glTexCoord2dv(const GLdouble *v)
2228 {
2229    DISPATCH_SETUP;
2230    DISPATCH(TexCoord2dv)(v);
2231 }
2232
2233 void GLAPIENTRY glTexCoord2fv(const GLfloat *v)
2234 {
2235    DISPATCH_SETUP;
2236    DISPATCH(TexCoord2fv)(v);
2237 }
2238
2239 void GLAPIENTRY glTexCoord2iv(const GLint *v)
2240 {
2241    DISPATCH_SETUP;
2242    DISPATCH(TexCoord2iv)(v);
2243 }
2244
2245 void GLAPIENTRY glTexCoord2sv(const GLshort *v)
2246 {
2247    DISPATCH_SETUP;
2248    DISPATCH(TexCoord2sv)(v);
2249 }
2250
2251 void GLAPIENTRY glTexCoord3dv(const GLdouble *v)
2252 {
2253    DISPATCH_SETUP;
2254    DISPATCH(TexCoord3dv)(v);
2255 }
2256
2257 void GLAPIENTRY glTexCoord3fv(const GLfloat *v)
2258 {
2259    DISPATCH_SETUP;
2260    DISPATCH(TexCoord3fv)(v);
2261 }
2262
2263 void GLAPIENTRY glTexCoord3iv(const GLint *v)
2264 {
2265    DISPATCH_SETUP;
2266    DISPATCH(TexCoord3iv)(v);
2267 }
2268
2269 void GLAPIENTRY glTexCoord3sv(const GLshort *v)
2270 {
2271    DISPATCH_SETUP;
2272    DISPATCH(TexCoord3sv)(v);
2273 }
2274
2275 void GLAPIENTRY glTexCoord4dv(const GLdouble *v)
2276 {
2277    DISPATCH_SETUP;
2278    DISPATCH(TexCoord4dv)(v);
2279 }
2280
2281 void GLAPIENTRY glTexCoord4fv(const GLfloat *v)
2282 {
2283    DISPATCH_SETUP;
2284    DISPATCH(TexCoord4fv)(v);
2285 }
2286
2287 void GLAPIENTRY glTexCoord4iv(const GLint *v)
2288 {
2289    DISPATCH_SETUP;
2290    DISPATCH(TexCoord4iv)(v);
2291 }
2292
2293 void GLAPIENTRY glTexCoord4sv(const GLshort *v)
2294 {
2295    DISPATCH_SETUP;
2296    DISPATCH(TexCoord4sv)(v);
2297 }
2298
2299 void GLAPIENTRY glTexGend(GLenum coord, GLenum pname, GLdouble param)
2300 {
2301    DISPATCH_SETUP;
2302    DISPATCH(TexGend)(coord, pname, param);
2303 }
2304
2305 void GLAPIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
2306 {
2307    DISPATCH_SETUP;
2308    DISPATCH(TexGendv)(coord, pname, params);
2309 }
2310
2311 void GLAPIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2312 {
2313    DISPATCH_SETUP;
2314    DISPATCH(TexGenf)(coord, pname, param);
2315 }
2316
2317 void GLAPIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
2318 {
2319    DISPATCH_SETUP;
2320    DISPATCH(TexGenfv)(coord, pname, params);
2321 }
2322
2323 void GLAPIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param)
2324 {
2325    DISPATCH_SETUP;
2326    DISPATCH(TexGeni)(coord, pname, param);
2327 }
2328
2329 void GLAPIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
2330 {
2331    DISPATCH_SETUP;
2332    DISPATCH(TexGeniv)(coord, pname, params);
2333 }
2334
2335 void GLAPIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2336 {
2337    DISPATCH_SETUP;
2338    DISPATCH(TexEnvf)(target, pname, param);
2339 }
2340
2341 void GLAPIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *param)
2342 {
2343    DISPATCH_SETUP;
2344    DISPATCH(TexEnvfv)(target, pname, param);
2345 }
2346
2347 void GLAPIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param)
2348 {
2349    DISPATCH_SETUP;
2350    DISPATCH(TexEnvi)(target, pname, param);
2351 }
2352
2353 void GLAPIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *param)
2354 {
2355    DISPATCH_SETUP;
2356    DISPATCH(TexEnviv)(target, pname, param);
2357 }
2358
2359 void GLAPIENTRY glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2360 {
2361    DISPATCH_SETUP;
2362    DISPATCH(TexImage1D)(target, level, internalformat, width, border, format, type, pixels);
2363 }
2364
2365 void GLAPIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2366 {
2367    DISPATCH_SETUP;
2368    DISPATCH(TexImage2D)(target, level, internalformat, width, height, border, format, type, pixels);
2369 }
2370
2371 void GLAPIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2372 {
2373    DISPATCH_SETUP;
2374    DISPATCH(TexParameterf)(target, pname, param);
2375 }
2376
2377 void GLAPIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
2378 {
2379    DISPATCH_SETUP;
2380    DISPATCH(TexParameterfv)(target, pname, params);
2381 }
2382
2383 void GLAPIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
2384 {
2385    DISPATCH_SETUP;
2386    DISPATCH(TexParameteri)(target, pname, param);
2387 }
2388
2389 void GLAPIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
2390 {
2391    DISPATCH_SETUP;
2392    DISPATCH(TexParameteriv)(target, pname, params);
2393 }
2394
2395 void GLAPIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z)
2396 {
2397    DISPATCH_SETUP;
2398    DISPATCH(Translated)(x, y, z);
2399 }
2400
2401 void GLAPIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
2402 {
2403    DISPATCH_SETUP;
2404    DISPATCH(Translatef)(x, y, z);
2405 }
2406
2407 void GLAPIENTRY glVertex2d(GLdouble x, GLdouble y)
2408 {
2409    DISPATCH_SETUP;
2410    DISPATCH(Vertex2d)(x, y);
2411 }
2412
2413 void GLAPIENTRY glVertex2dv(const GLdouble *v)
2414 {
2415    DISPATCH_SETUP;
2416    DISPATCH(Vertex2dv)(v);
2417 }
2418
2419 void GLAPIENTRY glVertex2f(GLfloat x, GLfloat y)
2420 {
2421    DISPATCH_SETUP;
2422    DISPATCH(Vertex2f)(x, y);
2423 }
2424
2425 void GLAPIENTRY glVertex2fv(const GLfloat *v)
2426 {
2427    DISPATCH_SETUP;
2428    DISPATCH(Vertex2fv)(v);
2429 }
2430
2431 void GLAPIENTRY glVertex2i(GLint x, GLint y)
2432 {
2433    DISPATCH_SETUP;
2434    DISPATCH(Vertex2i)(x, y);
2435 }
2436
2437 void GLAPIENTRY glVertex2iv(const GLint *v)
2438 {
2439    DISPATCH_SETUP;
2440    DISPATCH(Vertex2iv)(v);
2441 }
2442
2443 void GLAPIENTRY glVertex2s(GLshort x, GLshort y)
2444 {
2445    DISPATCH_SETUP;
2446    DISPATCH(Vertex2s)(x, y);
2447 }
2448
2449 void GLAPIENTRY glVertex2sv(const GLshort *v)
2450 {
2451    DISPATCH_SETUP;
2452    DISPATCH(Vertex2sv)(v);
2453 }
2454
2455 void GLAPIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z)
2456 {
2457    DISPATCH_SETUP;
2458    DISPATCH(Vertex3d)(x, y, z);
2459 }
2460
2461 void GLAPIENTRY glVertex3dv(const GLdouble *v)
2462 {
2463    DISPATCH_SETUP;
2464    DISPATCH(Vertex3dv)(v);
2465 }
2466
2467 void GLAPIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z)
2468 {
2469    DISPATCH_SETUP;
2470    DISPATCH(Vertex3f)(x, y, z);
2471 }
2472
2473 void GLAPIENTRY glVertex3fv(const GLfloat *v)
2474 {
2475    DISPATCH_SETUP;
2476    DISPATCH(Vertex3fv)(v);
2477 }
2478
2479 void GLAPIENTRY glVertex3i(GLint x, GLint y, GLint z)
2480 {
2481    DISPATCH_SETUP;
2482    DISPATCH(Vertex3i)(x, y, z);
2483 }
2484
2485 void GLAPIENTRY glVertex3iv(const GLint *v)
2486 {
2487    DISPATCH_SETUP;
2488    DISPATCH(Vertex3iv)(v);
2489 }
2490
2491 void GLAPIENTRY glVertex3s(GLshort x, GLshort y, GLshort z)
2492 {
2493    DISPATCH_SETUP;
2494    DISPATCH(Vertex3s)(x, y, z);
2495 }
2496
2497 void GLAPIENTRY glVertex3sv(const GLshort *v)
2498 {
2499    DISPATCH_SETUP;
2500    DISPATCH(Vertex3sv)(v);
2501 }
2502
2503 void GLAPIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2504 {
2505    DISPATCH_SETUP;
2506    DISPATCH(Vertex4d)(x, y, z, w);
2507 }
2508
2509 void GLAPIENTRY glVertex4dv(const GLdouble *v)
2510 {
2511    DISPATCH_SETUP;
2512    DISPATCH(Vertex4dv)(v);
2513 }
2514
2515 void GLAPIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2516 {
2517    DISPATCH_SETUP;
2518    DISPATCH(Vertex4f)(x, y, z, w);
2519 }
2520
2521 void GLAPIENTRY glVertex4fv(const GLfloat *v)
2522 {
2523    DISPATCH_SETUP;
2524    DISPATCH(Vertex4fv)(v);
2525 }
2526
2527 void GLAPIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w)
2528 {
2529    DISPATCH_SETUP;
2530    DISPATCH(Vertex4i)(x, y, z, w);
2531 }
2532
2533 void GLAPIENTRY glVertex4iv(const GLint *v)
2534 {
2535    DISPATCH_SETUP;
2536    DISPATCH(Vertex4iv)(v);
2537 }
2538
2539 void GLAPIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2540 {
2541    DISPATCH_SETUP;
2542    DISPATCH(Vertex4s)(x, y, z, w);
2543 }
2544
2545 void GLAPIENTRY glVertex4sv(const GLshort *v)
2546 {
2547    DISPATCH_SETUP;
2548    DISPATCH(Vertex4sv)(v);
2549 }
2550
2551 void GLAPIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2552 {
2553    DISPATCH_SETUP;
2554    DISPATCH(Viewport)(x, y, width, height);
2555 }
2556
2557
2558
2559
2560 #ifdef _GLAPI_VERSION_1_1
2561
2562 GLboolean GLAPIENTRY glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
2563 {
2564    DISPATCH_SETUP;
2565    return DISPATCH(AreTexturesResident)(n, textures, residences);
2566 }
2567
2568 void GLAPIENTRY glArrayElement(GLint i)
2569 {
2570    DISPATCH_SETUP;
2571    DISPATCH(ArrayElement)(i);
2572 }
2573
2574 void GLAPIENTRY glBindTexture(GLenum target, GLuint texture)
2575 {
2576    DISPATCH_SETUP;
2577    DISPATCH(BindTexture)(target, texture);
2578 }
2579
2580 void GLAPIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
2581 {
2582    DISPATCH_SETUP;
2583    DISPATCH(ColorPointer)(size, type, stride, ptr);
2584 }
2585
2586 void GLAPIENTRY glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
2587 {
2588    DISPATCH_SETUP;
2589    DISPATCH(CopyTexImage1D)(target, level, internalformat, x, y, width, border);
2590 }
2591
2592 void GLAPIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
2593 {
2594    DISPATCH_SETUP;
2595    DISPATCH(CopyTexImage2D)(target, level, internalformat, x, y, width, height, border);
2596 }
2597
2598 void GLAPIENTRY glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
2599 {
2600    DISPATCH_SETUP;
2601    DISPATCH(CopyTexSubImage1D)(target, level, xoffset, x, y, width);
2602 }
2603
2604 void GLAPIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2605 {
2606    DISPATCH_SETUP;
2607    DISPATCH(CopyTexSubImage2D)(target, level, xoffset, yoffset, x, y, width, height);
2608 }
2609
2610 void GLAPIENTRY glDeleteTextures(GLsizei n, const GLuint *textures)
2611 {
2612    DISPATCH_SETUP;
2613    DISPATCH(DeleteTextures)(n, textures);
2614 }
2615
2616 void GLAPIENTRY glDisableClientState(GLenum cap)
2617 {
2618    DISPATCH_SETUP;
2619    DISPATCH(DisableClientState)(cap);
2620 }
2621
2622 void GLAPIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)
2623 {
2624    DISPATCH_SETUP;
2625    DISPATCH(DrawArrays)(mode, first, count);
2626 }
2627
2628 void GLAPIENTRY glEdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
2629 {
2630    DISPATCH_SETUP;
2631    DISPATCH(EdgeFlagPointer)(stride, ptr);
2632 }
2633
2634 void GLAPIENTRY glEnableClientState(GLenum cap)
2635 {
2636    DISPATCH_SETUP;
2637    DISPATCH(EnableClientState)(cap);
2638 }
2639
2640 void GLAPIENTRY glGenTextures(GLsizei n, GLuint *textures)
2641 {
2642    DISPATCH_SETUP;
2643    DISPATCH(GenTextures)(n, textures);
2644 }
2645
2646 void GLAPIENTRY glGetPointerv(GLenum pname, GLvoid **params)
2647 {
2648    DISPATCH_SETUP;
2649    DISPATCH(GetPointerv)(pname, params);
2650 }
2651
2652 void GLAPIENTRY glIndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
2653 {
2654    DISPATCH_SETUP;
2655    DISPATCH(IndexPointer)(type, stride, ptr);
2656 }
2657
2658 void GLAPIENTRY glNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
2659 {
2660    DISPATCH_SETUP;
2661    DISPATCH(NormalPointer)(type, stride, ptr);
2662 }
2663
2664 void GLAPIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
2665 {
2666    DISPATCH_SETUP;
2667    DISPATCH(PolygonOffset)(factor, units);
2668 }
2669
2670 void GLAPIENTRY glPopClientAttrib(void)
2671 {
2672    DISPATCH_SETUP;
2673    DISPATCH(PopClientAttrib)();
2674 }
2675
2676 void GLAPIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
2677 {
2678    DISPATCH_SETUP;
2679    DISPATCH(PrioritizeTextures)(n, textures, priorities);
2680 }
2681
2682 void GLAPIENTRY glPushClientAttrib(GLbitfield mask)
2683 {
2684    DISPATCH_SETUP;
2685    DISPATCH(PushClientAttrib)(mask);
2686 }
2687
2688 void GLAPIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
2689 {
2690    DISPATCH_SETUP;
2691    DISPATCH(TexCoordPointer)(size, type, stride, ptr);
2692 }
2693
2694 void GLAPIENTRY glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
2695 {
2696    DISPATCH_SETUP;
2697    DISPATCH(TexSubImage1D)(target, level, xoffset, width, format, type, pixels);
2698 }
2699
2700 void GLAPIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
2701 {
2702    DISPATCH_SETUP;
2703    DISPATCH(TexSubImage2D)(target, level, xoffset, yoffset, width, height, format, type, pixels);
2704 }
2705
2706 void GLAPIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
2707 {
2708    DISPATCH_SETUP;
2709    DISPATCH(VertexPointer)(size, type, stride, ptr);
2710 }
2711
2712 #endif  /*_GLAPI_VERSION_1_1*/
2713
2714
2715
2716 #ifdef _GLAPI_VERSION_1_2
2717
2718 void GLAPIENTRY glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2719 {
2720    DISPATCH_SETUP;
2721    DISPATCH(CopyTexSubImage3D)(target, level, xoffset, yoffset, zoffset, x, y, width, height);
2722 }
2723
2724 void GLAPIENTRY glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
2725 {
2726    DISPATCH_SETUP;
2727    DISPATCH(DrawRangeElements)(mode, start, end, count, type, indices);
2728 }
2729
2730 void GLAPIENTRY glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2731 {
2732    DISPATCH_SETUP;
2733    DISPATCH(TexImage3D)(target, level, internalformat, width, height, depth, border, format, type, pixels);
2734 }
2735
2736 void GLAPIENTRY glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
2737 {
2738    DISPATCH_SETUP;
2739    DISPATCH(TexSubImage3D)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
2740 }
2741
2742
2743 #ifdef _GLAPI_ARB_imaging
2744
2745 void GLAPIENTRY glBlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a)
2746 {
2747    DISPATCH_SETUP;
2748    DISPATCH(BlendColor)(r, g, b, a);
2749 }
2750
2751 void GLAPIENTRY glBlendEquation(GLenum mode)
2752 {
2753    DISPATCH_SETUP;
2754    DISPATCH(BlendEquation)(mode);
2755 }
2756
2757 void GLAPIENTRY glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
2758 {
2759    DISPATCH_SETUP;
2760    DISPATCH(ColorSubTable)(target, start, count, format, type, data);
2761 }
2762
2763 void GLAPIENTRY glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
2764 {
2765    DISPATCH_SETUP;
2766    DISPATCH(ColorTable)(target, internalformat, width, format, type, table);
2767 }
2768
2769 void GLAPIENTRY glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
2770 {
2771    DISPATCH_SETUP;
2772    DISPATCH(ColorTableParameterfv)(target, pname, params);
2773 }
2774
2775 void GLAPIENTRY glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
2776 {
2777    DISPATCH_SETUP;
2778    DISPATCH(ColorTableParameteriv)(target, pname, params);
2779 }
2780
2781 void GLAPIENTRY glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
2782 {
2783    DISPATCH_SETUP;
2784    DISPATCH(ConvolutionFilter1D)(target, internalformat, width, format, type, image);
2785 }
2786
2787 void GLAPIENTRY glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
2788 {
2789    DISPATCH_SETUP;
2790    DISPATCH(ConvolutionFilter2D)(target, internalformat, width, height, format, type, image);
2791 }
2792
2793 void GLAPIENTRY glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
2794 {
2795    DISPATCH_SETUP;
2796    DISPATCH(ConvolutionParameterf)(target, pname, params);
2797 }
2798
2799 void GLAPIENTRY glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
2800 {
2801    DISPATCH_SETUP;
2802    DISPATCH(ConvolutionParameterfv)(target, pname, params);
2803 }
2804
2805 void GLAPIENTRY glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
2806 {
2807    DISPATCH_SETUP;
2808    DISPATCH(ConvolutionParameteri)(target, pname, params);
2809 }
2810
2811 void GLAPIENTRY glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
2812 {
2813    DISPATCH_SETUP;
2814    DISPATCH(ConvolutionParameteriv)(target, pname, params);
2815 }
2816
2817 void GLAPIENTRY glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
2818 {
2819    DISPATCH_SETUP;
2820    DISPATCH(CopyColorSubTable)(target, start, x, y, width);
2821 }
2822
2823 void GLAPIENTRY glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
2824 {
2825    DISPATCH_SETUP;
2826    DISPATCH(CopyColorTable)(target, internalformat, x, y, width);
2827 }
2828
2829 void GLAPIENTRY glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
2830 {
2831    DISPATCH_SETUP;
2832    DISPATCH(CopyConvolutionFilter1D)(target, internalformat, x, y, width);
2833 }
2834
2835 void GLAPIENTRY glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
2836 {
2837    DISPATCH_SETUP;
2838    DISPATCH(CopyConvolutionFilter2D)(target, internalformat, x, y, width, height);
2839 }
2840
2841 void GLAPIENTRY glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
2842 {
2843    DISPATCH_SETUP;
2844    DISPATCH(GetColorTable)(target, format, type, table);
2845 }
2846
2847 void GLAPIENTRY glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
2848 {
2849    DISPATCH_SETUP;
2850    DISPATCH(GetColorTableParameterfv)(target, pname, params);
2851 }
2852
2853 void GLAPIENTRY glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
2854 {
2855    DISPATCH_SETUP;
2856    DISPATCH(GetColorTableParameteriv)(target, pname, params);
2857 }
2858
2859 void GLAPIENTRY glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
2860 {
2861    DISPATCH_SETUP;
2862    DISPATCH(GetConvolutionFilter)(target, format, type, image);
2863 }
2864
2865 void GLAPIENTRY glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
2866 {
2867    DISPATCH_SETUP;
2868    DISPATCH(GetConvolutionParameterfv)(target, pname, params);
2869 }
2870
2871 void GLAPIENTRY glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
2872 {
2873    DISPATCH_SETUP;
2874    DISPATCH(GetConvolutionParameteriv)(target, pname, params);
2875 }
2876
2877 void GLAPIENTRY glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
2878 {
2879    DISPATCH_SETUP;
2880    DISPATCH(GetHistogram)(target, reset, format, type, values);
2881 }
2882
2883 void GLAPIENTRY glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
2884 {
2885    DISPATCH_SETUP;
2886    DISPATCH(GetHistogramParameterfv)(target, pname, params);
2887 }
2888
2889 void GLAPIENTRY glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
2890 {
2891    DISPATCH_SETUP;
2892    DISPATCH(GetHistogramParameteriv)(target, pname, params);
2893 }
2894
2895 void GLAPIENTRY glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values)
2896 {
2897    DISPATCH_SETUP;
2898    DISPATCH(GetMinmax)(target, reset, format, types, values);
2899 }
2900
2901 void GLAPIENTRY glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
2902 {
2903    DISPATCH_SETUP;
2904    DISPATCH(GetMinmaxParameterfv)(target, pname, params);
2905 }
2906
2907 void GLAPIENTRY glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
2908 {
2909    DISPATCH_SETUP;
2910    DISPATCH(GetMinmaxParameteriv)(target, pname, params);
2911 }
2912
2913 void GLAPIENTRY glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
2914 {
2915    DISPATCH_SETUP;
2916    DISPATCH(GetSeparableFilter)(target, format, type, row, column, span);
2917 }
2918
2919 void GLAPIENTRY glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
2920 {
2921    DISPATCH_SETUP;
2922    DISPATCH(Histogram)(target, width, internalformat, sink);
2923 }
2924
2925 void GLAPIENTRY glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
2926 {
2927    DISPATCH_SETUP;
2928    DISPATCH(Minmax)(target, internalformat, sink);
2929 }
2930
2931 void GLAPIENTRY glResetMinmax(GLenum target)
2932 {
2933    DISPATCH_SETUP;
2934    DISPATCH(ResetMinmax)(target);
2935 }
2936
2937 void GLAPIENTRY glResetHistogram(GLenum target)
2938 {
2939    DISPATCH_SETUP;
2940    DISPATCH(ResetHistogram)(target);
2941 }
2942
2943 void GLAPIENTRY glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
2944 {
2945    DISPATCH_SETUP;
2946    DISPATCH(SeparableFilter2D)(target, internalformat, width, height, format, type, row, column);
2947 }
2948
2949
2950 #endif  /*_GLAPI_ARB_imaging*/
2951 #endif  /*_GLAPI_VERSION_1_2*/
2952
2953
2954
2955 /***
2956  *** Extension functions
2957  ***/
2958
2959 #ifdef _GLAPI_EXT_blend_minmax
2960 void GLAPIENTRY glBlendEquationEXT(GLenum mode)
2961 {
2962    DISPATCH_SETUP;
2963    DISPATCH(BlendEquationEXT)(mode);
2964 }
2965 #endif
2966
2967
2968 #ifdef _GLAPI_EXT_blend_color
2969 void GLAPIENTRY glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
2970 {
2971    DISPATCH_SETUP;
2972    DISPATCH(BlendColorEXT)(red, green, blue, alpha);
2973 }
2974 #endif
2975
2976
2977 #ifdef _GLAPI_EXT_polygon_offset
2978 void GLAPIENTRY glPolygonOffsetEXT(GLfloat factor, GLfloat bias)
2979 {
2980    DISPATCH_SETUP;
2981    DISPATCH(PolygonOffsetEXT)(factor, bias);
2982 }
2983 #endif
2984
2985
2986
2987 #ifdef _GLAPI_EXT_vertex_array
2988
2989 void GLAPIENTRY glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr)
2990 {
2991    DISPATCH_SETUP;
2992    (void) count;
2993    DISPATCH(VertexPointer)(size, type, stride, ptr);
2994 }
2995
2996 void GLAPIENTRY glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr)
2997 {
2998    DISPATCH_SETUP;
2999    (void) count;
3000    DISPATCH(NormalPointer)(type, stride, ptr);
3001 }
3002
3003 void GLAPIENTRY glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr)
3004 {
3005    DISPATCH_SETUP;
3006    (void) count;
3007    DISPATCH(ColorPointer)(size, type, stride, ptr);
3008 }
3009
3010 void GLAPIENTRY glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr)
3011 {
3012    DISPATCH_SETUP;
3013    (void) count;
3014    DISPATCH(IndexPointer)(type, stride, ptr);
3015 }
3016
3017 void GLAPIENTRY glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr)
3018 {
3019    DISPATCH_SETUP;
3020    (void) count;
3021    DISPATCH(ColorPointer)(size, type, stride, ptr);
3022 }
3023
3024 void GLAPIENTRY glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
3025 {
3026    DISPATCH_SETUP;
3027    (void) count;
3028    DISPATCH(EdgeFlagPointer)(stride, ptr);
3029 }
3030
3031 void GLAPIENTRY glGetPointervEXT(GLenum pname, void **params)
3032 {
3033    DISPATCH_SETUP;
3034    DISPATCH(GetPointerv)(pname, params);
3035 }
3036
3037 void GLAPIENTRY glArrayElementEXT(GLint i)
3038 {
3039    DISPATCH_SETUP;
3040    DISPATCH(ArrayElement)(i);
3041 }
3042
3043 void GLAPIENTRY glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
3044 {
3045    DISPATCH_SETUP;
3046    DISPATCH(DrawArrays)(mode, first, count);
3047 }
3048
3049 #endif  /* GL_EXT_vertex_arrays */
3050
3051
3052
3053 #ifdef _GLAPI_EXT_texture_object
3054
3055 void GLAPIENTRY glGenTexturesEXT(GLsizei n, GLuint *textures)
3056 {
3057    DISPATCH_SETUP;
3058    DISPATCH(GenTextures)(n, textures);
3059 }
3060
3061 void GLAPIENTRY glDeleteTexturesEXT(GLsizei n, const GLuint *texture)
3062 {
3063    DISPATCH_SETUP;
3064    DISPATCH(DeleteTextures)(n, texture);
3065 }
3066
3067 void GLAPIENTRY glBindTextureEXT(GLenum target, GLuint texture)
3068 {
3069    DISPATCH_SETUP;
3070    DISPATCH(BindTexture)(target, texture);
3071 }
3072
3073 void GLAPIENTRY glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities)
3074 {
3075    DISPATCH_SETUP;
3076    DISPATCH(PrioritizeTextures)(n, textures, priorities);
3077 }
3078
3079 GLboolean GLAPIENTRY glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences)
3080 {
3081    DISPATCH_SETUP;
3082    DISPATCH(AreTexturesResident)(n, textures, residences);
3083    return GL_FALSE;
3084 }
3085
3086 GLboolean GLAPIENTRY glIsTextureEXT(GLuint texture)
3087 {
3088    DISPATCH_SETUP;
3089    DISPATCH(IsTexture)(texture);
3090    return GL_FALSE;
3091 }
3092 #endif  /* GL_EXT_texture_object */
3093
3094
3095
3096 #ifdef _GLAPI_EXT_texture3D
3097
3098 void GLAPIENTRY glTexImage3DEXT(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
3099 {
3100    DISPATCH_SETUP;
3101    DISPATCH(TexImage3D)(target, level, internalFormat, width, height, depth, border, format, type, pixels);
3102 }
3103
3104 void GLAPIENTRY glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
3105 {
3106    DISPATCH_SETUP;
3107    DISPATCH(TexSubImage3D)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3108 }
3109
3110 void GLAPIENTRY glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
3111 {
3112    DISPATCH_SETUP;
3113    DISPATCH(CopyTexSubImage3D)(target, level, xoffset, yoffset, zoffset, x, y, width, height);
3114 }
3115
3116 #endif  /* GL_EXT_texture3D*/
3117
3118
3119
3120 #ifdef _GLAPI_EXT_paletted_texture
3121
3122 void GLAPIENTRY glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
3123 {
3124    DISPATCH_SETUP;
3125    DISPATCH(ColorTableEXT)(target, internalformat, width, format, type, table);
3126 }
3127
3128 void GLAPIENTRY glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
3129 {
3130    DISPATCH_SETUP;
3131    DISPATCH(ColorSubTableEXT)(target, start, count, format, type, data);
3132 }
3133
3134 void GLAPIENTRY glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
3135 {
3136    DISPATCH_SETUP;
3137    DISPATCH(GetColorTableEXT)(target, format, type, table);
3138 }
3139
3140 void GLAPIENTRY glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
3141 {
3142    DISPATCH_SETUP;
3143    DISPATCH(GetColorTableParameterfvEXT)(target, pname, params);
3144 }
3145
3146 void GLAPIENTRY glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params)
3147 {
3148    DISPATCH_SETUP;
3149    DISPATCH(GetColorTableParameterivEXT)(target, pname, params);
3150 }
3151
3152 #endif  /* GL_EXT_paletted_texture */
3153
3154
3155
3156 #ifdef _GLAPI_EXT_compiled_vertex_array
3157
3158 void GLAPIENTRY glLockArraysEXT(GLint first, GLsizei count)
3159 {
3160    DISPATCH_SETUP;
3161    DISPATCH(LockArraysEXT)(first, count);
3162 }
3163
3164 void GLAPIENTRY glUnlockArraysEXT(void)
3165 {
3166    DISPATCH_SETUP;
3167    DISPATCH(UnlockArraysEXT)();
3168 }
3169
3170 #endif  /* GL_EXT_compiled_vertex_array */
3171
3172
3173
3174 #ifdef _GLAPI_EXT_point_parameters
3175
3176 void GLAPIENTRY glPointParameterfEXT(GLenum target, GLfloat param)
3177 {
3178    DISPATCH_SETUP;
3179    DISPATCH(PointParameterfEXT)(target, param);
3180 }
3181
3182 void GLAPIENTRY glPointParameterfvEXT(GLenum target, const GLfloat *param)
3183 {
3184    DISPATCH_SETUP;
3185    DISPATCH(PointParameterfvEXT)(target, param);
3186 }
3187
3188 #endif  /* GL_EXT_point_parameters */
3189
3190
3191
3192 #ifdef _GLAPI_ARB_multitexture
3193
3194 void GLAPIENTRY glActiveTextureARB(GLenum texture)
3195 {
3196    DISPATCH_SETUP;
3197    DISPATCH(ActiveTextureARB)(texture);
3198 }
3199
3200 void GLAPIENTRY glClientActiveTextureARB(GLenum texture)
3201 {
3202    DISPATCH_SETUP;
3203    DISPATCH(ClientActiveTextureARB)(texture);
3204 }
3205
3206 void GLAPIENTRY glMultiTexCoord1dARB(GLenum target, GLdouble s)
3207 {
3208    DISPATCH_SETUP;
3209    DISPATCH(MultiTexCoord1dARB)(target, s);
3210 }
3211
3212 void GLAPIENTRY glMultiTexCoord1dvARB(GLenum target, const GLdouble *v)
3213 {
3214    DISPATCH_SETUP;
3215    DISPATCH(MultiTexCoord1dvARB)(target, v);
3216 }
3217
3218 void GLAPIENTRY glMultiTexCoord1fARB(GLenum target, GLfloat s)
3219 {
3220    DISPATCH_SETUP;
3221    DISPATCH(MultiTexCoord1fARB)(target, s);
3222 }
3223
3224 void GLAPIENTRY glMultiTexCoord1fvARB(GLenum target, const GLfloat *v)
3225 {
3226    DISPATCH_SETUP;
3227    DISPATCH(MultiTexCoord1fvARB)(target, v);
3228 }
3229
3230 void GLAPIENTRY glMultiTexCoord1iARB(GLenum target, GLint s)
3231 {
3232    DISPATCH_SETUP;
3233    DISPATCH(MultiTexCoord1iARB)(target, s);
3234 }
3235
3236 void GLAPIENTRY glMultiTexCoord1ivARB(GLenum target, const GLint *v)
3237 {
3238    DISPATCH_SETUP;
3239    DISPATCH(MultiTexCoord1ivARB)(target, v);
3240 }
3241
3242 void GLAPIENTRY glMultiTexCoord1sARB(GLenum target, GLshort s)
3243 {
3244    DISPATCH_SETUP;
3245    DISPATCH(MultiTexCoord1sARB)(target, s);
3246 }
3247
3248 void GLAPIENTRY glMultiTexCoord1svARB(GLenum target, const GLshort *v)
3249 {
3250    DISPATCH_SETUP;
3251    DISPATCH(MultiTexCoord1svARB)(target, v);
3252 }
3253
3254 void GLAPIENTRY glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
3255 {
3256    DISPATCH_SETUP;
3257    DISPATCH(MultiTexCoord2dARB)(target, s, t);
3258 }
3259
3260 void GLAPIENTRY glMultiTexCoord2dvARB(GLenum target, const GLdouble *v)
3261 {
3262    DISPATCH_SETUP;
3263    DISPATCH(MultiTexCoord2dvARB)(target, v);
3264 }
3265
3266 void GLAPIENTRY glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
3267 {
3268    DISPATCH_SETUP;
3269    DISPATCH(MultiTexCoord2fARB)(target, s, t);
3270 }
3271
3272 void GLAPIENTRY glMultiTexCoord2fvARB(GLenum target, const GLfloat *v)
3273 {
3274    DISPATCH_SETUP;
3275    DISPATCH(MultiTexCoord2fvARB)(target, v);
3276 }
3277
3278 void GLAPIENTRY glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
3279 {
3280    DISPATCH_SETUP;
3281    DISPATCH(MultiTexCoord2iARB)(target, s, t);
3282 }
3283
3284 void GLAPIENTRY glMultiTexCoord2ivARB(GLenum target, const GLint *v)
3285 {
3286    DISPATCH_SETUP;
3287    DISPATCH(MultiTexCoord2ivARB)(target, v);
3288 }
3289
3290 void GLAPIENTRY glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
3291 {
3292    DISPATCH_SETUP;
3293    DISPATCH(MultiTexCoord2sARB)(target, s, t);
3294 }
3295
3296 void GLAPIENTRY glMultiTexCoord2svARB(GLenum target, const GLshort *v)
3297 {
3298    DISPATCH_SETUP;
3299    DISPATCH(MultiTexCoord2svARB)(target, v);
3300 }
3301
3302 void GLAPIENTRY glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
3303 {
3304    DISPATCH_SETUP;
3305    DISPATCH(MultiTexCoord3dARB)(target, s, t, r);
3306 }
3307
3308 void GLAPIENTRY glMultiTexCoord3dvARB(GLenum target, const GLdouble *v)
3309 {
3310    DISPATCH_SETUP;
3311    DISPATCH(MultiTexCoord3dvARB)(target, v);
3312 }
3313
3314 void GLAPIENTRY glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
3315 {
3316    DISPATCH_SETUP;
3317    DISPATCH(MultiTexCoord3fARB)(target, s, t, r);
3318 }
3319
3320 void GLAPIENTRY glMultiTexCoord3fvARB(GLenum target, const GLfloat *v)
3321 {
3322    DISPATCH_SETUP;
3323    DISPATCH(MultiTexCoord3fvARB)(target, v);
3324 }
3325
3326 void GLAPIENTRY glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
3327 {
3328    DISPATCH_SETUP;
3329    DISPATCH(MultiTexCoord3iARB)(target, s, t, r);
3330 }
3331
3332 void GLAPIENTRY glMultiTexCoord3ivARB(GLenum target, const GLint *v)
3333 {
3334    DISPATCH_SETUP;
3335    DISPATCH(MultiTexCoord3ivARB)(target, v);
3336 }
3337
3338 void GLAPIENTRY glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
3339 {
3340    DISPATCH_SETUP;
3341    DISPATCH(MultiTexCoord3sARB)(target, s, t, r);
3342 }
3343
3344 void GLAPIENTRY glMultiTexCoord3svARB(GLenum target, const GLshort *v)
3345 {
3346    DISPATCH_SETUP;
3347    DISPATCH(MultiTexCoord3svARB)(target, v);
3348 }
3349
3350 void GLAPIENTRY glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
3351 {
3352    DISPATCH_SETUP;
3353    DISPATCH(MultiTexCoord4dARB)(target, s, t, r, q);
3354 }
3355
3356 void GLAPIENTRY glMultiTexCoord4dvARB(GLenum target, const GLdouble *v)
3357 {
3358    DISPATCH_SETUP;
3359    DISPATCH(MultiTexCoord4dvARB)(target, v);
3360 }
3361
3362 void GLAPIENTRY glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
3363 {
3364    DISPATCH_SETUP;
3365    DISPATCH(MultiTexCoord4fARB)(target, s, t, r, q);
3366 }
3367
3368 void GLAPIENTRY glMultiTexCoord4fvARB(GLenum target, const GLfloat *v)
3369 {
3370    DISPATCH_SETUP;
3371    DISPATCH(MultiTexCoord4fvARB)(target, v);
3372 }
3373
3374 void GLAPIENTRY glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
3375 {
3376    DISPATCH_SETUP;
3377    DISPATCH(MultiTexCoord4iARB)(target, s, t, r, q);
3378 }
3379
3380 void GLAPIENTRY glMultiTexCoord4ivARB(GLenum target, const GLint *v)
3381 {
3382    DISPATCH_SETUP;
3383    DISPATCH(MultiTexCoord4ivARB)(target, v);
3384 }
3385
3386 void GLAPIENTRY glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
3387 {
3388    DISPATCH_SETUP;
3389    DISPATCH(MultiTexCoord4sARB)(target, s, t, r, q);
3390 }
3391
3392 void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v)
3393 {
3394    DISPATCH_SETUP;
3395    DISPATCH(MultiTexCoord4svARB)(target, v);
3396 }
3397
3398 #endif  /* GL_ARB_multitexture */
3399
3400
3401
3402 #ifdef _GLAPI_INGR_blend_func_separate
3403 void GLAPIENTRY glBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
3404 {
3405    DISPATCH_SETUP;
3406    DISPATCH(BlendFuncSeparateINGR)(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
3407 }
3408 #endif  /* GL_INGR_blend_func_separate */
3409
3410
3411
3412 #ifdef _GLAPI_MESA_window_pos
3413
3414 void GLAPIENTRY glWindowPos2iMESA(GLint x, GLint y)
3415 {
3416    DISPATCH_SETUP;
3417    DISPATCH(WindowPos4fMESA)(x, y, 0, 1);
3418 }
3419
3420 void GLAPIENTRY glWindowPos2sMESA(GLshort x, GLshort y)
3421 {
3422    DISPATCH_SETUP;
3423    DISPATCH(WindowPos4fMESA)(x, y, 0, 1);
3424 }
3425
3426 void GLAPIENTRY glWindowPos2fMESA(GLfloat x, GLfloat y)
3427 {
3428    DISPATCH_SETUP;
3429    DISPATCH(WindowPos4fMESA)(x, y, 0, 1);
3430 }
3431
3432 void GLAPIENTRY glWindowPos2dMESA(GLdouble x, GLdouble y)
3433 {
3434    DISPATCH_SETUP;
3435    DISPATCH(WindowPos4fMESA)(x, y, 0, 1);
3436 }
3437
3438 void GLAPIENTRY glWindowPos2ivMESA(const GLint *p)
3439 {
3440    DISPATCH_SETUP;
3441    DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1);
3442 }
3443
3444 void GLAPIENTRY glWindowPos2svMESA(const GLshort *p)
3445 {
3446    DISPATCH_SETUP;
3447    DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1);
3448 }
3449
3450 void GLAPIENTRY glWindowPos2fvMESA(const GLfloat *p)
3451 {
3452    DISPATCH_SETUP;
3453    DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1);
3454 }
3455
3456 void GLAPIENTRY glWindowPos2dvMESA(const GLdouble *p)
3457 {
3458    DISPATCH_SETUP;
3459    DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1);
3460 }
3461
3462 void GLAPIENTRY glWindowPos3iMESA(GLint x, GLint y, GLint z)
3463 {
3464    DISPATCH_SETUP;
3465    DISPATCH(WindowPos4fMESA)(x, y, z, 1);
3466 }
3467
3468 void GLAPIENTRY glWindowPos3sMESA(GLshort x, GLshort y, GLshort z)
3469 {
3470    DISPATCH_SETUP;
3471    DISPATCH(WindowPos4fMESA)(x, y, z, 1);
3472 }
3473
3474 void GLAPIENTRY glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
3475 {
3476    DISPATCH_SETUP;
3477    DISPATCH(WindowPos4fMESA)(x, y, z, 1);
3478 }
3479
3480 void GLAPIENTRY glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
3481 {
3482    DISPATCH_SETUP;
3483    DISPATCH(WindowPos4fMESA)(x, y, z, 1);
3484 }
3485
3486 void GLAPIENTRY glWindowPos3ivMESA(const GLint *p)
3487 {
3488    DISPATCH_SETUP;
3489    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0);
3490 }
3491
3492 void GLAPIENTRY glWindowPos3svMESA(const GLshort *p)
3493 {
3494    DISPATCH_SETUP;
3495    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0);
3496 }
3497
3498 void GLAPIENTRY glWindowPos3fvMESA(const GLfloat *p)
3499 {
3500    DISPATCH_SETUP;
3501    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0);
3502 }
3503
3504 void GLAPIENTRY glWindowPos3dvMESA(const GLdouble *p)
3505 {
3506    DISPATCH_SETUP;
3507    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0);
3508 }
3509
3510 void GLAPIENTRY glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
3511 {
3512    DISPATCH_SETUP;
3513    DISPATCH(WindowPos4fMESA)(x, y, z, w);
3514 }
3515
3516 void GLAPIENTRY glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
3517 {
3518    DISPATCH_SETUP;
3519    DISPATCH(WindowPos4fMESA)(x, y, z, w);
3520 }
3521
3522 void GLAPIENTRY glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3523 {
3524    DISPATCH_SETUP;
3525    DISPATCH(WindowPos4fMESA)(x, y, z, w);
3526 }
3527
3528 void GLAPIENTRY glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3529 {
3530    DISPATCH_SETUP;
3531    DISPATCH(WindowPos4fMESA)(x, y, z, w);
3532 }
3533
3534 void GLAPIENTRY glWindowPos4ivMESA(const GLint *p)
3535 {
3536    DISPATCH_SETUP;
3537    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]);
3538 }
3539
3540 void GLAPIENTRY glWindowPos4svMESA(const GLshort *p)
3541 {
3542    DISPATCH_SETUP;
3543    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]);
3544 }
3545
3546 void GLAPIENTRY glWindowPos4fvMESA(const GLfloat *p)
3547 {
3548    DISPATCH_SETUP;
3549    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]);
3550 }
3551
3552 void GLAPIENTRY glWindowPos4dvMESA(const GLdouble *p)
3553 {
3554    DISPATCH_SETUP;
3555    DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]);
3556 }
3557
3558 #endif  /* GL_MESA_window_pos */
3559
3560
3561
3562 #ifdef _GLAPI_MESA_resize_buffers
3563 void GLAPIENTRY glResizeBuffersMESA(void)
3564 {
3565    DISPATCH_SETUP;
3566    DISPATCH(ResizeBuffersMESA)();
3567 }
3568 #endif  /* GL_MESA_resize_buffers */
3569
3570
3571
3572
3573 #ifdef DEBUG
3574 /*
3575  * This struct is just used to be sure we've defined all the API functions.
3576  */
3577 static struct _glapi_table completeness_test = {
3578    glAccum,
3579    glAlphaFunc,
3580    glBegin,
3581    glBitmap,
3582    glBlendFunc,
3583    glCallList,
3584    glCallLists,
3585    glClear,
3586    glClearAccum,
3587    glClearColor,
3588    glClearDepth,
3589    glClearIndex,
3590    glClearStencil,
3591    glClipPlane,
3592    glColor3b,
3593    glColor3bv,
3594    glColor3d,
3595    glColor3dv,
3596    glColor3f,
3597    glColor3fv,
3598    glColor3i,
3599    glColor3iv,
3600    glColor3s,
3601    glColor3sv,
3602    glColor3ub,
3603    glColor3ubv,
3604    glColor3ui,
3605    glColor3uiv,
3606    glColor3us,
3607    glColor3usv,
3608    glColor4b,
3609    glColor4bv,
3610    glColor4d,
3611    glColor4dv,
3612    glColor4f,
3613    glColor4fv,
3614    glColor4i,
3615    glColor4iv,
3616    glColor4s,
3617    glColor4sv,
3618    glColor4ub,
3619    glColor4ubv,
3620    glColor4ui,
3621    glColor4uiv,
3622    glColor4us,
3623    glColor4usv,
3624    glColorMask,
3625    glColorMaterial,
3626    glCopyPixels,
3627    glCullFace,
3628    glDeleteLists,
3629    glDepthFunc,
3630    glDepthMask,
3631    glDepthRange,
3632    glDisable,
3633    glDrawBuffer,
3634    glDrawPixels,
3635    glEdgeFlag,
3636    glEdgeFlagv,
3637    glEnable,
3638    glEnd,
3639    glEndList,
3640    glEvalCoord1d,
3641    glEvalCoord1dv,
3642    glEvalCoord1f,
3643    glEvalCoord1fv,
3644    glEvalCoord2d,
3645    glEvalCoord2dv,
3646    glEvalCoord2f,
3647    glEvalCoord2fv,
3648    glEvalMesh1,
3649    glEvalMesh2,
3650    glEvalPoint1,
3651    glEvalPoint2,
3652    glFeedbackBuffer,
3653    glFinish,
3654    glFlush,
3655    glFogf,
3656    glFogfv,
3657    glFogi,
3658    glFogiv,
3659    glFrontFace,
3660    glFrustum,
3661    glGenLists,
3662    glGetBooleanv,
3663    glGetClipPlane,
3664    glGetDoublev,
3665    glGetError,
3666    glGetFloatv,
3667    glGetIntegerv,
3668    glGetLightfv,
3669    glGetLightiv,
3670    glGetMapdv,
3671    glGetMapfv,
3672    glGetMapiv,
3673    glGetMaterialfv,
3674    glGetMaterialiv,
3675    glGetPixelMapfv,
3676    glGetPixelMapuiv,
3677    glGetPixelMapusv,
3678    glGetPolygonStipple,
3679    glGetString,
3680    glGetTexEnvfv,
3681    glGetTexEnviv,
3682    glGetTexGendv,
3683    glGetTexGenfv,
3684    glGetTexGeniv,
3685    glGetTexImage,
3686    glGetTexLevelParameterfv,
3687    glGetTexLevelParameteriv,
3688    glGetTexParameterfv,
3689    glGetTexParameteriv,
3690    glHint,
3691    glIndexMask,
3692    glIndexd,
3693    glIndexdv,
3694    glIndexf,
3695    glIndexfv,
3696    glIndexi,
3697    glIndexiv,
3698    glIndexs,
3699    glIndexsv,
3700    glInitNames,
3701    glIsEnabled,
3702    glIsList,
3703    glLightModelf,
3704    glLightModelfv,
3705    glLightModeli,
3706    glLightModeliv,
3707    glLightf,
3708    glLightfv,
3709    glLighti,
3710    glLightiv,
3711    glLineStipple,
3712    glLineWidth,
3713    glListBase,
3714    glLoadIdentity,
3715    glLoadMatrixd,
3716    glLoadMatrixf,
3717    glLoadName,
3718    glLogicOp,
3719    glMap1d,
3720    glMap1f,
3721    glMap2d,
3722    glMap2f,
3723    glMapGrid1d,
3724    glMapGrid1f,
3725    glMapGrid2d,
3726    glMapGrid2f,
3727    glMaterialf,
3728    glMaterialfv,
3729    glMateriali,
3730    glMaterialiv,
3731    glMatrixMode,
3732    glMultMatrixd,
3733    glMultMatrixf,
3734    glNewList,
3735    glNormal3b,
3736    glNormal3bv,
3737    glNormal3d,
3738    glNormal3dv,
3739    glNormal3f,
3740    glNormal3fv,
3741    glNormal3i,
3742    glNormal3iv,
3743    glNormal3s,
3744    glNormal3sv,
3745    glOrtho,
3746    glPassThrough,
3747    glPixelMapfv,
3748    glPixelMapuiv,
3749    glPixelMapusv,
3750    glPixelStoref,
3751    glPixelStorei,
3752    glPixelTransferf,
3753    glPixelTransferi,
3754    glPixelZoom,
3755    glPointSize,
3756    glPolygonMode,
3757    glPolygonOffset,
3758    glPolygonStipple,
3759    glPopAttrib,
3760    glPopMatrix,
3761    glPopName,
3762    glPushAttrib,
3763    glPushMatrix,
3764    glPushName,
3765    glRasterPos2d,
3766    glRasterPos2dv,
3767    glRasterPos2f,
3768    glRasterPos2fv,
3769    glRasterPos2i,
3770    glRasterPos2iv,
3771    glRasterPos2s,
3772    glRasterPos2sv,
3773    glRasterPos3d,
3774    glRasterPos3dv,
3775    glRasterPos3f,
3776    glRasterPos3fv,
3777    glRasterPos3i,
3778    glRasterPos3iv,
3779    glRasterPos3s,
3780    glRasterPos3sv,
3781    glRasterPos4d,
3782    glRasterPos4dv,
3783    glRasterPos4f,
3784    glRasterPos4fv,
3785    glRasterPos4i,
3786    glRasterPos4iv,
3787    glRasterPos4s,
3788    glRasterPos4sv,
3789    glReadBuffer,
3790    glReadPixels,
3791    glRectd,
3792    glRectdv,
3793    glRectf,
3794    glRectfv,
3795    glRecti,
3796    glRectiv,
3797    glRects,
3798    glRectsv,
3799    glRenderMode,
3800    glRotated,
3801    glRotatef,
3802    glScaled,
3803    glScalef,
3804    glScissor,
3805    glSelectBuffer,
3806    glShadeModel,
3807    glStencilFunc,
3808    glStencilMask,
3809    glStencilOp,
3810    glTexCoord1d,
3811    glTexCoord1dv,
3812    glTexCoord1f,
3813    glTexCoord1fv,
3814    glTexCoord1i,
3815    glTexCoord1iv,
3816    glTexCoord1s,
3817    glTexCoord1sv,
3818    glTexCoord2d,
3819    glTexCoord2dv,
3820    glTexCoord2f,
3821    glTexCoord2fv,
3822    glTexCoord2i,
3823    glTexCoord2iv,
3824    glTexCoord2s,
3825    glTexCoord2sv,
3826    glTexCoord3d,
3827    glTexCoord3dv,
3828    glTexCoord3f,
3829    glTexCoord3fv,
3830    glTexCoord3i,
3831    glTexCoord3iv,
3832    glTexCoord3s,
3833    glTexCoord3sv,
3834    glTexCoord4d,
3835    glTexCoord4dv,
3836    glTexCoord4f,
3837    glTexCoord4fv,
3838    glTexCoord4i,
3839    glTexCoord4iv,
3840    glTexCoord4s,
3841    glTexCoord4sv,
3842    glTexEnvf,
3843    glTexEnvfv,
3844    glTexEnvi,
3845    glTexEnviv,
3846    glTexGend,
3847    glTexGendv,
3848    glTexGenf,
3849    glTexGenfv,
3850    glTexGeni,
3851    glTexGeniv,
3852    glTexImage1D,
3853    glTexImage2D,
3854    glTexParameterf,
3855    glTexParameterfv,
3856    glTexParameteri,
3857    glTexParameteriv,
3858    glTranslated,
3859    glTranslatef,
3860    glVertex2d,
3861    glVertex2dv,
3862    glVertex2f,
3863    glVertex2fv,
3864    glVertex2i,
3865    glVertex2iv,
3866    glVertex2s,
3867    glVertex2sv,
3868    glVertex3d,
3869    glVertex3dv,
3870    glVertex3f,
3871    glVertex3fv,
3872    glVertex3i,
3873    glVertex3iv,
3874    glVertex3s,
3875    glVertex3sv,
3876    glVertex4d,
3877    glVertex4dv,
3878    glVertex4f,
3879    glVertex4fv,
3880    glVertex4i,
3881    glVertex4iv,
3882    glVertex4s,
3883    glVertex4sv,
3884    glViewport,
3885
3886 #ifdef _GLAPI_VERSION_1_1
3887    glAreTexturesResident,
3888    glArrayElement,
3889    glBindTexture,
3890    glColorPointer,
3891    glCopyTexImage1D,
3892    glCopyTexImage2D,
3893    glCopyTexSubImage1D,
3894    glCopyTexSubImage2D,
3895    glDeleteTextures,
3896    glDisableClientState,
3897    glDrawArrays,
3898    glDrawElements,
3899    glEdgeFlagPointer,
3900    glEnableClientState,
3901    glGenTextures,
3902    glGetPointerv,
3903    glIndexPointer,
3904    glIndexub,
3905    glIndexubv,
3906    glInterleavedArrays,
3907    glIsTexture,
3908    glNormalPointer,
3909    glPopClientAttrib,
3910    glPrioritizeTextures,
3911    glPushClientAttrib,
3912    glTexCoordPointer,
3913    glTexSubImage1D,
3914    glTexSubImage2D,
3915    glVertexPointer,
3916 #endif
3917
3918 #ifdef _GLAPI_VERSION_1_2
3919    glCopyTexSubImage3D,
3920    glDrawRangeElements,
3921    glTexImage3D,
3922    glTexSubImage3D,
3923
3924 #ifdef _GLAPI_ARB_imaging
3925    glBlendColor,
3926    glBlendEquation,
3927    glColorSubTable,
3928    glColorTable,
3929    glColorTableParameterfv,
3930    glColorTableParameteriv,
3931    glConvolutionFilter1D,
3932    glConvolutionFilter2D,
3933    glConvolutionParameterf,
3934    glConvolutionParameterfv,
3935    glConvolutionParameteri,
3936    glConvolutionParameteriv,
3937    glCopyColorSubTable,
3938    glCopyColorTable,
3939    glCopyConvolutionFilter1D,
3940    glCopyConvolutionFilter2D,
3941    glGetColorTable,
3942    glGetColorTableParameterfv,
3943    glGetColorTableParameteriv,
3944    glGetConvolutionFilter,
3945    glGetConvolutionParameterfv,
3946    glGetConvolutionParameteriv,
3947    glGetHistogram,
3948    glGetHistogramParameterfv,
3949    glGetHistogramParameteriv,
3950    glGetMinmax,
3951    glGetMinmaxParameterfv,
3952    glGetMinmaxParameteriv,
3953    glGetSeparableFilter,
3954    glHistogram,
3955    glMinmax,
3956    glResetHistogram,
3957    glResetMinmax,
3958    glSeparableFilter2D,
3959 #endif
3960 #endif
3961
3962
3963    /*
3964     * Extensions
3965     */
3966
3967 #ifdef _GLAPI_EXT_paletted_texture
3968    glColorTableEXT,
3969    glColorSubTableEXT,
3970    glGetColorTableEXT,
3971    glGetColorTableParameterfvEXT,
3972    glGetColorTableParameterivEXT,
3973 #endif
3974
3975 #ifdef _GLAPI_EXT_compiled_vertex_array
3976    glLockArraysEXT,
3977    glUnlockArraysEXT,
3978 #endif
3979
3980 #ifdef _GLAPI_EXT_point_parameters
3981    glPointParameterfEXT,
3982    glPointParameterfvEXT,
3983 #endif
3984
3985 #ifdef _GLAPI_EXT_polygon_offset
3986    glPolygonOffsetEXT,
3987 #endif
3988
3989 #ifdef _GLAPI_EXT_blend_minmax
3990    glBlendEquationEXT,
3991 #endif
3992
3993 #ifdef _GLAPI_EXT_blend_color
3994    glBlendColorEXT,
3995 #endif
3996
3997 #ifdef _GLAPI_ARB_multitexture
3998    glActiveTextureARB,
3999    glClientActiveTextureARB,
4000    glMultiTexCoord1dARB,
4001    glMultiTexCoord1dvARB,
4002    glMultiTexCoord1fARB,
4003    glMultiTexCoord1fvARB,
4004    glMultiTexCoord1iARB,
4005    glMultiTexCoord1ivARB,
4006    glMultiTexCoord1sARB,
4007    glMultiTexCoord1svARB,
4008    glMultiTexCoord2dARB,
4009    glMultiTexCoord2dvARB,
4010    glMultiTexCoord2fARB,
4011    glMultiTexCoord2fvARB,
4012    glMultiTexCoord2iARB,
4013    glMultiTexCoord2ivARB,
4014    glMultiTexCoord2sARB,
4015    glMultiTexCoord2svARB,
4016    glMultiTexCoord3dARB,
4017    glMultiTexCoord3dvARB,
4018    glMultiTexCoord3fARB,
4019    glMultiTexCoord3fvARB,
4020    glMultiTexCoord3iARB,
4021    glMultiTexCoord3ivARB,
4022    glMultiTexCoord3sARB,
4023    glMultiTexCoord3svARB,
4024    glMultiTexCoord4dARB,
4025    glMultiTexCoord4dvARB,
4026    glMultiTexCoord4fARB,
4027    glMultiTexCoord4fvARB,
4028    glMultiTexCoord4iARB,
4029    glMultiTexCoord4ivARB,
4030    glMultiTexCoord4sARB,
4031    glMultiTexCoord4svARB,
4032 #endif
4033
4034 #ifdef _GLAPI_INGR_blend_func_separate
4035    glBlendFuncSeparateINGR,
4036 #endif
4037
4038 #ifdef _GLAPI_MESA_window_pos
4039    glWindowPos4fMESA,
4040 #endif
4041
4042 #ifdef _GLAPI_MESA_resize_buffers
4043    glResizeBuffersMESA
4044 #endif
4045
4046 };
4047
4048 #endif /*DEBUG*/