src/mapi/glapi/tests/check_table.cpp

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <gtest/gtest.h>
  25 #include "main/glheader.h"
  26
  27 #include "glapi/glapi.h"
  28 #include "glapitable.h"
  29
  30 struct name_offset {
  31    const char *name;
  32    unsigned int offset;
  33 };
  34
  35 extern const struct name_offset linux_gl_abi[];
  36 extern const struct name_offset known_dispatch[];
  37
  38 TEST(GetProcAddress, ABIOffsetByName)
  39 {
  40    /* 408 functions have had their locations in the dispatch table set since
  41     * the dawn of time.  Verify that all of these functions are at the correct
  42     * locations.
  43     */
  44    for (unsigned i = 0; linux_gl_abi[i].name != NULL; i++) {
  45       EXPECT_EQ(linux_gl_abi[i].offset,
  46                 _glapi_get_proc_offset(linux_gl_abi[i].name))
  47          << "function name: " << linux_gl_abi[i].name;
  48    }
  49 }
  50
  51 TEST(GetProcAddress, ABINameByOffset)
  52 {
  53    /* 408 functions have had their locations in the dispatch table set since
  54     * the dawn of time.  Verify that all of these functions are at the correct
  55     * locations.
  56     */
  57    for (unsigned i = 0; linux_gl_abi[i].name != NULL; i++) {
  58       EXPECT_STREQ(linux_gl_abi[i].name,
  59                    _glapi_get_proc_name(linux_gl_abi[i].offset))
  60          << "function offset: " << linux_gl_abi[i].offset;
  61    }
  62 }
  63
  64 TEST(GetProcAddress, TableBigEnoughForABI)
  65 {
  66    const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *);
  67
  68    EXPECT_GE(table_entries, 408u);
  69 }
  70
  71 TEST(GetProcAddress, TableDidntShrink)
  72 {
  73    const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *);
  74
  75    /* The dispatch table is not expected to shrink.  At GIT commit b45052b the
  76     * table had 978 entries.  Changes that intentionally reduce the size of
  77     * the table are very rare.  In those cases, the expected value should be
  78     * updated to reflect the change.
  79     *
  80     * Changes that accidentally reduce the size of the table are bugs, and
  81     * they should be fixed.
  82     *
  83     * 6 entries were removed when GL_SGIS_pixel_texture was removed from the
  84     * dispatch table.
  85     *
  86     * 1 entry was removed when GL_SGIX_pixel_texture was removed from the
  87     * dispatch table.
  88     *
  89     * 2 entries were removed when GL_APPLE_texture_range was removed from the
  90     * dispatch table.
  91     *
  92     * 13 entries were removed when GL_NV_register_combiners was removed from
  93     * the dispatch table.
  94     *
  95     * 7 entries were removed when GL_NV_fence was removed from the dispatch
  96     * table.
  97     *
  98     * 2 entries were removed when GL_NV_vertex_array_range was removed from
  99     * the dispatch table.
 100     */
 101    EXPECT_GE(table_entries, 978u - 6u - 1u - 2u - 13u - 7u - 2u);
 102 }
 103
 104 TEST(GetProcAddress, QueriedDispatchSizeBigEnough)
 105 {
 106    const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *);
 107
 108    /* _glapi_get_dispatch_table_size returns the size of the extended dispatch
 109     * table.  This is the size of the static table with some extra entries for
 110     * drivers to use for extensions that the core does not know about.
 111     */
 112    EXPECT_LT(table_entries, _glapi_get_dispatch_table_size());
 113 }
 114
 115 TEST(GetProcAddress, KnownDispatchOffsetsAreConsistent)
 116 {
 117    /* Verify that the queried dispatch offset for every known function is
 118     * consistent with its location in the static dispatch table.
 119     *
 120     * There is some redundancy between this test and ABIOffsetByName.  That's
 121     * okay.  The offsets in ABIOffsetByName comdirectly from the ABI
 122     * definition.  The offsets in this test come from locations in a structure
 123     * definition generated by scripts.
 124     */
 125    for (unsigned i = 0; known_dispatch[i].name != NULL; i++) {
 126       EXPECT_EQ(known_dispatch[i].offset,
 127                 _glapi_get_proc_offset(known_dispatch[i].name))
 128          << "function name: " << known_dispatch[i].name;
 129    }
 130 }
 131
 132 TEST(GetProcAddress, KnownDispatchNamesAreConsistent)
 133 {
 134    /* Verify that the queried dispatch name for every known function is
 135     * consistent with its location in the static dispatch table.
 136     *
 137     * There is some redundancy between this test and ABINameByOffset.  That's
 138     * okay.  The offsets in ABIOffsetByName comdirectly from the ABI
 139     * definition.  The offsets in this test come from locations in a structure
 140     * definition generated by scripts.
 141     */
 142    for (unsigned i = 0; known_dispatch[i].name != NULL; i++) {
 143       EXPECT_STREQ(known_dispatch[i].name,
 144                    _glapi_get_proc_name(known_dispatch[i].offset))
 145          << "function offset: " << known_dispatch[i].offset;
 146    }
 147 }
 148
 149 const struct name_offset linux_gl_abi[] = {
 150    { "glNewList", 0 },
 151    { "glEndList", 1 },
 152    { "glCallList", 2 },
 153    { "glCallLists", 3 },
 154    { "glDeleteLists", 4 },
 155    { "glGenLists", 5 },
 156    { "glListBase", 6 },
 157    { "glBegin", 7 },
 158    { "glBitmap", 8 },
 159    { "glColor3b", 9 },
 160    { "glColor3bv", 10 },
 161    { "glColor3d", 11 },
 162    { "glColor3dv", 12 },
 163    { "glColor3f", 13 },
 164    { "glColor3fv", 14 },
 165    { "glColor3i", 15 },
 166    { "glColor3iv", 16 },
 167    { "glColor3s", 17 },
 168    { "glColor3sv", 18 },
 169    { "glColor3ub", 19 },
 170    { "glColor3ubv", 20 },
 171    { "glColor3ui", 21 },
 172    { "glColor3uiv", 22 },
 173    { "glColor3us", 23 },
 174    { "glColor3usv", 24 },
 175    { "glColor4b", 25 },
 176    { "glColor4bv", 26 },
 177    { "glColor4d", 27 },
 178    { "glColor4dv", 28 },
 179    { "glColor4f", 29 },
 180    { "glColor4fv", 30 },
 181    { "glColor4i", 31 },
 182    { "glColor4iv", 32 },
 183    { "glColor4s", 33 },
 184    { "glColor4sv", 34 },
 185    { "glColor4ub", 35 },
 186    { "glColor4ubv", 36 },
 187    { "glColor4ui", 37 },
 188    { "glColor4uiv", 38 },
 189    { "glColor4us", 39 },
 190    { "glColor4usv", 40 },
 191    { "glEdgeFlag", 41 },
 192    { "glEdgeFlagv", 42 },
 193    { "glEnd", 43 },
 194    { "glIndexd", 44 },
 195    { "glIndexdv", 45 },
 196    { "glIndexf", 46 },
 197    { "glIndexfv", 47 },
 198    { "glIndexi", 48 },
 199    { "glIndexiv", 49 },
 200    { "glIndexs", 50 },
 201    { "glIndexsv", 51 },
 202    { "glNormal3b", 52 },
 203    { "glNormal3bv", 53 },
 204    { "glNormal3d", 54 },
 205    { "glNormal3dv", 55 },
 206    { "glNormal3f", 56 },
 207    { "glNormal3fv", 57 },
 208    { "glNormal3i", 58 },
 209    { "glNormal3iv", 59 },
 210    { "glNormal3s", 60 },
 211    { "glNormal3sv", 61 },
 212    { "glRasterPos2d", 62 },
 213    { "glRasterPos2dv", 63 },
 214    { "glRasterPos2f", 64 },
 215    { "glRasterPos2fv", 65 },
 216    { "glRasterPos2i", 66 },
 217    { "glRasterPos2iv", 67 },
 218    { "glRasterPos2s", 68 },
 219    { "glRasterPos2sv", 69 },
 220    { "glRasterPos3d", 70 },
 221    { "glRasterPos3dv", 71 },
 222    { "glRasterPos3f", 72 },
 223    { "glRasterPos3fv", 73 },
 224    { "glRasterPos3i", 74 },
 225    { "glRasterPos3iv", 75 },
 226    { "glRasterPos3s", 76 },
 227    { "glRasterPos3sv", 77 },
 228    { "glRasterPos4d", 78 },
 229    { "glRasterPos4dv", 79 },
 230    { "glRasterPos4f", 80 },
 231    { "glRasterPos4fv", 81 },
 232    { "glRasterPos4i", 82 },
 233    { "glRasterPos4iv", 83 },
 234    { "glRasterPos4s", 84 },
 235    { "glRasterPos4sv", 85 },
 236    { "glRectd", 86 },
 237    { "glRectdv", 87 },
 238    { "glRectf", 88 },
 239    { "glRectfv", 89 },
 240    { "glRecti", 90 },
 241    { "glRectiv", 91 },
 242    { "glRects", 92 },
 243    { "glRectsv", 93 },
 244    { "glTexCoord1d", 94 },
 245    { "glTexCoord1dv", 95 },
 246    { "glTexCoord1f", 96 },
 247    { "glTexCoord1fv", 97 },
 248    { "glTexCoord1i", 98 },
 249    { "glTexCoord1iv", 99 },
 250    { "glTexCoord1s", 100 },
 251    { "glTexCoord1sv", 101 },
 252    { "glTexCoord2d", 102 },
 253    { "glTexCoord2dv", 103 },
 254    { "glTexCoord2f", 104 },
 255    { "glTexCoord2fv", 105 },
 256    { "glTexCoord2i", 106 },
 257    { "glTexCoord2iv", 107 },
 258    { "glTexCoord2s", 108 },
 259    { "glTexCoord2sv", 109 },
 260    { "glTexCoord3d", 110 },
 261    { "glTexCoord3dv", 111 },
 262    { "glTexCoord3f", 112 },
 263    { "glTexCoord3fv", 113 },
 264    { "glTexCoord3i", 114 },
 265    { "glTexCoord3iv", 115 },
 266    { "glTexCoord3s", 116 },
 267    { "glTexCoord3sv", 117 },
 268    { "glTexCoord4d", 118 },
 269    { "glTexCoord4dv", 119 },
 270    { "glTexCoord4f", 120 },
 271    { "glTexCoord4fv", 121 },
 272    { "glTexCoord4i", 122 },
 273    { "glTexCoord4iv", 123 },
 274    { "glTexCoord4s", 124 },
 275    { "glTexCoord4sv", 125 },
 276    { "glVertex2d", 126 },
 277    { "glVertex2dv", 127 },
 278    { "glVertex2f", 128 },
 279    { "glVertex2fv", 129 },
 280    { "glVertex2i", 130 },
 281    { "glVertex2iv", 131 },
 282    { "glVertex2s", 132 },
 283    { "glVertex2sv", 133 },
 284    { "glVertex3d", 134 },
 285    { "glVertex3dv", 135 },
 286    { "glVertex3f", 136 },
 287    { "glVertex3fv", 137 },
 288    { "glVertex3i", 138 },
 289    { "glVertex3iv", 139 },
 290    { "glVertex3s", 140 },
 291    { "glVertex3sv", 141 },
 292    { "glVertex4d", 142 },
 293    { "glVertex4dv", 143 },
 294    { "glVertex4f", 144 },
 295    { "glVertex4fv", 145 },
 296    { "glVertex4i", 146 },
 297    { "glVertex4iv", 147 },
 298    { "glVertex4s", 148 },
 299    { "glVertex4sv", 149 },
 300    { "glClipPlane", 150 },
 301    { "glColorMaterial", 151 },
 302    { "glCullFace", 152 },
 303    { "glFogf", 153 },
 304    { "glFogfv", 154 },
 305    { "glFogi", 155 },
 306    { "glFogiv", 156 },
 307    { "glFrontFace", 157 },
 308    { "glHint", 158 },
 309    { "glLightf", 159 },
 310    { "glLightfv", 160 },
 311    { "glLighti", 161 },
 312    { "glLightiv", 162 },
 313    { "glLightModelf", 163 },
 314    { "glLightModelfv", 164 },
 315    { "glLightModeli", 165 },
 316    { "glLightModeliv", 166 },
 317    { "glLineStipple", 167 },
 318    { "glLineWidth", 168 },
 319    { "glMaterialf", 169 },
 320    { "glMaterialfv", 170 },
 321    { "glMateriali", 171 },
 322    { "glMaterialiv", 172 },
 323    { "glPointSize", 173 },
 324    { "glPolygonMode", 174 },
 325    { "glPolygonStipple", 175 },
 326    { "glScissor", 176 },
 327    { "glShadeModel", 177 },
 328    { "glTexParameterf", 178 },
 329    { "glTexParameterfv", 179 },
 330    { "glTexParameteri", 180 },
 331    { "glTexParameteriv", 181 },
 332    { "glTexImage1D", 182 },
 333    { "glTexImage2D", 183 },
 334    { "glTexEnvf", 184 },
 335    { "glTexEnvfv", 185 },
 336    { "glTexEnvi", 186 },
 337    { "glTexEnviv", 187 },
 338    { "glTexGend", 188 },
 339    { "glTexGendv", 189 },
 340    { "glTexGenf", 190 },
 341    { "glTexGenfv", 191 },
 342    { "glTexGeni", 192 },
 343    { "glTexGeniv", 193 },
 344    { "glFeedbackBuffer", 194 },
 345    { "glSelectBuffer", 195 },
 346    { "glRenderMode", 196 },
 347    { "glInitNames", 197 },
 348    { "glLoadName", 198 },
 349    { "glPassThrough", 199 },
 350    { "glPopName", 200 },
 351    { "glPushName", 201 },
 352    { "glDrawBuffer", 202 },
 353    { "glClear", 203 },
 354    { "glClearAccum", 204 },
 355    { "glClearIndex", 205 },
 356    { "glClearColor", 206 },
 357    { "glClearStencil", 207 },
 358    { "glClearDepth", 208 },
 359    { "glStencilMask", 209 },
 360    { "glColorMask", 210 },
 361    { "glDepthMask", 211 },
 362    { "glIndexMask", 212 },
 363    { "glAccum", 213 },
 364    { "glDisable", 214 },
 365    { "glEnable", 215 },
 366    { "glFinish", 216 },
 367    { "glFlush", 217 },
 368    { "glPopAttrib", 218 },
 369    { "glPushAttrib", 219 },
 370    { "glMap1d", 220 },
 371    { "glMap1f", 221 },
 372    { "glMap2d", 222 },
 373    { "glMap2f", 223 },
 374    { "glMapGrid1d", 224 },
 375    { "glMapGrid1f", 225 },
 376    { "glMapGrid2d", 226 },
 377    { "glMapGrid2f", 227 },
 378    { "glEvalCoord1d", 228 },
 379    { "glEvalCoord1dv", 229 },
 380    { "glEvalCoord1f", 230 },
 381    { "glEvalCoord1fv", 231 },
 382    { "glEvalCoord2d", 232 },
 383    { "glEvalCoord2dv", 233 },
 384    { "glEvalCoord2f", 234 },
 385    { "glEvalCoord2fv", 235 },
 386    { "glEvalMesh1", 236 },
 387    { "glEvalPoint1", 237 },
 388    { "glEvalMesh2", 238 },
 389    { "glEvalPoint2", 239 },
 390    { "glAlphaFunc", 240 },
 391    { "glBlendFunc", 241 },
 392    { "glLogicOp", 242 },
 393    { "glStencilFunc", 243 },
 394    { "glStencilOp", 244 },
 395    { "glDepthFunc", 245 },
 396    { "glPixelZoom", 246 },
 397    { "glPixelTransferf", 247 },
 398    { "glPixelTransferi", 248 },
 399    { "glPixelStoref", 249 },
 400    { "glPixelStorei", 250 },
 401    { "glPixelMapfv", 251 },
 402    { "glPixelMapuiv", 252 },
 403    { "glPixelMapusv", 253 },
 404    { "glReadBuffer", 254 },
 405    { "glCopyPixels", 255 },
 406    { "glReadPixels", 256 },
 407    { "glDrawPixels", 257 },
 408    { "glGetBooleanv", 258 },
 409    { "glGetClipPlane", 259 },
 410    { "glGetDoublev", 260 },
 411    { "glGetError", 261 },
 412    { "glGetFloatv", 262 },
 413    { "glGetIntegerv", 263 },
 414    { "glGetLightfv", 264 },
 415    { "glGetLightiv", 265 },
 416    { "glGetMapdv", 266 },
 417    { "glGetMapfv", 267 },
 418    { "glGetMapiv", 268 },
 419    { "glGetMaterialfv", 269 },
 420    { "glGetMaterialiv", 270 },
 421    { "glGetPixelMapfv", 271 },
 422    { "glGetPixelMapuiv", 272 },
 423    { "glGetPixelMapusv", 273 },
 424    { "glGetPolygonStipple", 274 },
 425    { "glGetString", 275 },
 426    { "glGetTexEnvfv", 276 },
 427    { "glGetTexEnviv", 277 },
 428    { "glGetTexGendv", 278 },
 429    { "glGetTexGenfv", 279 },
 430    { "glGetTexGeniv", 280 },
 431    { "glGetTexImage", 281 },
 432    { "glGetTexParameterfv", 282 },
 433    { "glGetTexParameteriv", 283 },
 434    { "glGetTexLevelParameterfv", 284 },
 435    { "glGetTexLevelParameteriv", 285 },
 436    { "glIsEnabled", 286 },
 437    { "glIsList", 287 },
 438    { "glDepthRange", 288 },
 439    { "glFrustum", 289 },
 440    { "glLoadIdentity", 290 },
 441    { "glLoadMatrixf", 291 },
 442    { "glLoadMatrixd", 292 },
 443    { "glMatrixMode", 293 },
 444    { "glMultMatrixf", 294 },
 445    { "glMultMatrixd", 295 },
 446    { "glOrtho", 296 },
 447    { "glPopMatrix", 297 },
 448    { "glPushMatrix", 298 },
 449    { "glRotated", 299 },
 450    { "glRotatef", 300 },
 451    { "glScaled", 301 },
 452    { "glScalef", 302 },
 453    { "glTranslated", 303 },
 454    { "glTranslatef", 304 },
 455    { "glViewport", 305 },
 456    { "glArrayElement", 306 },
 457    { "glColorPointer", 308 },
 458    { "glDisableClientState", 309 },
 459    { "glDrawArrays", 310 },
 460    { "glDrawElements", 311 },
 461    { "glEdgeFlagPointer", 312 },
 462    { "glEnableClientState", 313 },
 463    { "glGetPointerv", 329 },
 464    { "glIndexPointer", 314 },
 465    { "glInterleavedArrays", 317 },
 466    { "glNormalPointer", 318 },
 467    { "glTexCoordPointer", 320 },
 468    { "glVertexPointer", 321 },
 469    { "glPolygonOffset", 319 },
 470    { "glCopyTexImage1D", 323 },
 471    { "glCopyTexImage2D", 324 },
 472    { "glCopyTexSubImage1D", 325 },
 473    { "glCopyTexSubImage2D", 326 },
 474    { "glTexSubImage1D", 332 },
 475    { "glTexSubImage2D", 333 },
 476    { "glAreTexturesResident", 322 },
 477    { "glBindTexture", 307 },
 478    { "glDeleteTextures", 327 },
 479    { "glGenTextures", 328 },
 480    { "glIsTexture", 330 },
 481    { "glPrioritizeTextures", 331 },
 482    { "glIndexub", 315 },
 483    { "glIndexubv", 316 },
 484    { "glPopClientAttrib", 334 },
 485    { "glPushClientAttrib", 335 },
 486    { "glBlendColor", 336 },
 487    { "glBlendEquation", 337 },
 488    { "glDrawRangeElements", 338 },
 489    { "glColorTable", 339 },
 490    { "glColorTableParameterfv", 340 },
 491    { "glColorTableParameteriv", 341 },
 492    { "glCopyColorTable", 342 },
 493    { "glGetColorTable", 343 },
 494    { "glGetColorTableParameterfv", 344 },
 495    { "glGetColorTableParameteriv", 345 },
 496    { "glColorSubTable", 346 },
 497    { "glCopyColorSubTable", 347 },
 498    { "glConvolutionFilter1D", 348 },
 499    { "glConvolutionFilter2D", 349 },
 500    { "glConvolutionParameterf", 350 },
 501    { "glConvolutionParameterfv", 351 },
 502    { "glConvolutionParameteri", 352 },
 503    { "glConvolutionParameteriv", 353 },
 504    { "glCopyConvolutionFilter1D", 354 },
 505    { "glCopyConvolutionFilter2D", 355 },
 506    { "glGetConvolutionFilter", 356 },
 507    { "glGetConvolutionParameterfv", 357 },
 508    { "glGetConvolutionParameteriv", 358 },
 509    { "glGetSeparableFilter", 359 },
 510    { "glSeparableFilter2D", 360 },
 511    { "glGetHistogram", 361 },
 512    { "glGetHistogramParameterfv", 362 },
 513    { "glGetHistogramParameteriv", 363 },
 514    { "glGetMinmax", 364 },
 515    { "glGetMinmaxParameterfv", 365 },
 516    { "glGetMinmaxParameteriv", 366 },
 517    { "glHistogram", 367 },
 518    { "glMinmax", 368 },
 519    { "glResetHistogram", 369 },
 520    { "glResetMinmax", 370 },
 521    { "glTexImage3D", 371 },
 522    { "glTexSubImage3D", 372 },
 523    { "glCopyTexSubImage3D", 373 },
 524    { "glActiveTexture", 374 },
 525    { "glClientActiveTexture", 375 },
 526    { "glMultiTexCoord1d", 376 },
 527    { "glMultiTexCoord1dv", 377 },
 528    { "glMultiTexCoord1fARB", 378 },
 529    { "glMultiTexCoord1fvARB", 379 },
 530    { "glMultiTexCoord1i", 380 },
 531    { "glMultiTexCoord1iv", 381 },
 532    { "glMultiTexCoord1s", 382 },
 533    { "glMultiTexCoord1sv", 383 },
 534    { "glMultiTexCoord2d", 384 },
 535    { "glMultiTexCoord2dv", 385 },
 536    { "glMultiTexCoord2fARB", 386 },
 537    { "glMultiTexCoord2fvARB", 387 },
 538    { "glMultiTexCoord2i", 388 },
 539    { "glMultiTexCoord2iv", 389 },
 540    { "glMultiTexCoord2s", 390 },
 541    { "glMultiTexCoord2sv", 391 },
 542    { "glMultiTexCoord3d", 392 },
 543    { "glMultiTexCoord3dv", 393 },
 544    { "glMultiTexCoord3fARB", 394 },
 545    { "glMultiTexCoord3fvARB", 395 },
 546    { "glMultiTexCoord3i", 396 },
 547    { "glMultiTexCoord3iv", 397 },
 548    { "glMultiTexCoord3s", 398 },
 549    { "glMultiTexCoord3sv", 399 },
 550    { "glMultiTexCoord4d", 400 },
 551    { "glMultiTexCoord4dv", 401 },
 552    { "glMultiTexCoord4fARB", 402 },
 553    { "glMultiTexCoord4fvARB", 403 },
 554    { "glMultiTexCoord4i", 404 },
 555    { "glMultiTexCoord4iv", 405 },
 556    { "glMultiTexCoord4s", 406 },
 557    { "glMultiTexCoord4sv", 407 },
 558    { NULL, 0 }
 559 };
 560
 561 #define _O(f) ((intptr_t) & (((struct _glapi_table *) 0)->f)) / sizeof(void *)
 562
 563 const struct name_offset known_dispatch[] = {
 564    { "glNewList", _O(NewList) },
 565    { "glEndList", _O(EndList) },
 566    { "glCallList", _O(CallList) },
 567    { "glCallLists", _O(CallLists) },
 568    { "glDeleteLists", _O(DeleteLists) },
 569    { "glGenLists", _O(GenLists) },
 570    { "glListBase", _O(ListBase) },
 571    { "glBegin", _O(Begin) },
 572    { "glBitmap", _O(Bitmap) },
 573    { "glColor3b", _O(Color3b) },
 574    { "glColor3bv", _O(Color3bv) },
 575    { "glColor3d", _O(Color3d) },
 576    { "glColor3dv", _O(Color3dv) },
 577    { "glColor3f", _O(Color3f) },
 578    { "glColor3fv", _O(Color3fv) },
 579    { "glColor3i", _O(Color3i) },
 580    { "glColor3iv", _O(Color3iv) },
 581    { "glColor3s", _O(Color3s) },
 582    { "glColor3sv", _O(Color3sv) },
 583    { "glColor3ub", _O(Color3ub) },
 584    { "glColor3ubv", _O(Color3ubv) },
 585    { "glColor3ui", _O(Color3ui) },
 586    { "glColor3uiv", _O(Color3uiv) },
 587    { "glColor3us", _O(Color3us) },
 588    { "glColor3usv", _O(Color3usv) },
 589    { "glColor4b", _O(Color4b) },
 590    { "glColor4bv", _O(Color4bv) },
 591    { "glColor4d", _O(Color4d) },
 592    { "glColor4dv", _O(Color4dv) },
 593    { "glColor4f", _O(Color4f) },
 594    { "glColor4fv", _O(Color4fv) },
 595    { "glColor4i", _O(Color4i) },
 596    { "glColor4iv", _O(Color4iv) },
 597    { "glColor4s", _O(Color4s) },
 598    { "glColor4sv", _O(Color4sv) },
 599    { "glColor4ub", _O(Color4ub) },
 600    { "glColor4ubv", _O(Color4ubv) },
 601    { "glColor4ui", _O(Color4ui) },
 602    { "glColor4uiv", _O(Color4uiv) },
 603    { "glColor4us", _O(Color4us) },
 604    { "glColor4usv", _O(Color4usv) },
 605    { "glEdgeFlag", _O(EdgeFlag) },
 606    { "glEdgeFlagv", _O(EdgeFlagv) },
 607    { "glEnd", _O(End) },
 608    { "glIndexd", _O(Indexd) },
 609    { "glIndexdv", _O(Indexdv) },
 610    { "glIndexf", _O(Indexf) },
 611    { "glIndexfv", _O(Indexfv) },
 612    { "glIndexi", _O(Indexi) },
 613    { "glIndexiv", _O(Indexiv) },
 614    { "glIndexs", _O(Indexs) },
 615    { "glIndexsv", _O(Indexsv) },
 616    { "glNormal3b", _O(Normal3b) },
 617    { "glNormal3bv", _O(Normal3bv) },
 618    { "glNormal3d", _O(Normal3d) },
 619    { "glNormal3dv", _O(Normal3dv) },
 620    { "glNormal3f", _O(Normal3f) },
 621    { "glNormal3fv", _O(Normal3fv) },
 622    { "glNormal3i", _O(Normal3i) },
 623    { "glNormal3iv", _O(Normal3iv) },
 624    { "glNormal3s", _O(Normal3s) },
 625    { "glNormal3sv", _O(Normal3sv) },
 626    { "glRasterPos2d", _O(RasterPos2d) },
 627    { "glRasterPos2dv", _O(RasterPos2dv) },
 628    { "glRasterPos2f", _O(RasterPos2f) },
 629    { "glRasterPos2fv", _O(RasterPos2fv) },
 630    { "glRasterPos2i", _O(RasterPos2i) },
 631    { "glRasterPos2iv", _O(RasterPos2iv) },
 632    { "glRasterPos2s", _O(RasterPos2s) },
 633    { "glRasterPos2sv", _O(RasterPos2sv) },
 634    { "glRasterPos3d", _O(RasterPos3d) },
 635    { "glRasterPos3dv", _O(RasterPos3dv) },
 636    { "glRasterPos3f", _O(RasterPos3f) },
 637    { "glRasterPos3fv", _O(RasterPos3fv) },
 638    { "glRasterPos3i", _O(RasterPos3i) },
 639    { "glRasterPos3iv", _O(RasterPos3iv) },
 640    { "glRasterPos3s", _O(RasterPos3s) },
 641    { "glRasterPos3sv", _O(RasterPos3sv) },
 642    { "glRasterPos4d", _O(RasterPos4d) },
 643    { "glRasterPos4dv", _O(RasterPos4dv) },
 644    { "glRasterPos4f", _O(RasterPos4f) },
 645    { "glRasterPos4fv", _O(RasterPos4fv) },
 646    { "glRasterPos4i", _O(RasterPos4i) },
 647    { "glRasterPos4iv", _O(RasterPos4iv) },
 648    { "glRasterPos4s", _O(RasterPos4s) },
 649    { "glRasterPos4sv", _O(RasterPos4sv) },
 650    { "glRectd", _O(Rectd) },
 651    { "glRectdv", _O(Rectdv) },
 652    { "glRectf", _O(Rectf) },
 653    { "glRectfv", _O(Rectfv) },
 654    { "glRecti", _O(Recti) },
 655    { "glRectiv", _O(Rectiv) },
 656    { "glRects", _O(Rects) },
 657    { "glRectsv", _O(Rectsv) },
 658    { "glTexCoord1d", _O(TexCoord1d) },
 659    { "glTexCoord1dv", _O(TexCoord1dv) },
 660    { "glTexCoord1f", _O(TexCoord1f) },
 661    { "glTexCoord1fv", _O(TexCoord1fv) },
 662    { "glTexCoord1i", _O(TexCoord1i) },
 663    { "glTexCoord1iv", _O(TexCoord1iv) },
 664    { "glTexCoord1s", _O(TexCoord1s) },
 665    { "glTexCoord1sv", _O(TexCoord1sv) },
 666    { "glTexCoord2d", _O(TexCoord2d) },
 667    { "glTexCoord2dv", _O(TexCoord2dv) },
 668    { "glTexCoord2f", _O(TexCoord2f) },
 669    { "glTexCoord2fv", _O(TexCoord2fv) },
 670    { "glTexCoord2i", _O(TexCoord2i) },
 671    { "glTexCoord2iv", _O(TexCoord2iv) },
 672    { "glTexCoord2s", _O(TexCoord2s) },
 673    { "glTexCoord2sv", _O(TexCoord2sv) },
 674    { "glTexCoord3d", _O(TexCoord3d) },
 675    { "glTexCoord3dv", _O(TexCoord3dv) },
 676    { "glTexCoord3f", _O(TexCoord3f) },
 677    { "glTexCoord3fv", _O(TexCoord3fv) },
 678    { "glTexCoord3i", _O(TexCoord3i) },
 679    { "glTexCoord3iv", _O(TexCoord3iv) },
 680    { "glTexCoord3s", _O(TexCoord3s) },
 681    { "glTexCoord3sv", _O(TexCoord3sv) },
 682    { "glTexCoord4d", _O(TexCoord4d) },
 683    { "glTexCoord4dv", _O(TexCoord4dv) },
 684    { "glTexCoord4f", _O(TexCoord4f) },
 685    { "glTexCoord4fv", _O(TexCoord4fv) },
 686    { "glTexCoord4i", _O(TexCoord4i) },
 687    { "glTexCoord4iv", _O(TexCoord4iv) },
 688    { "glTexCoord4s", _O(TexCoord4s) },
 689    { "glTexCoord4sv", _O(TexCoord4sv) },
 690    { "glVertex2d", _O(Vertex2d) },
 691    { "glVertex2dv", _O(Vertex2dv) },
 692    { "glVertex2f", _O(Vertex2f) },
 693    { "glVertex2fv", _O(Vertex2fv) },
 694    { "glVertex2i", _O(Vertex2i) },
 695    { "glVertex2iv", _O(Vertex2iv) },
 696    { "glVertex2s", _O(Vertex2s) },
 697    { "glVertex2sv", _O(Vertex2sv) },
 698    { "glVertex3d", _O(Vertex3d) },
 699    { "glVertex3dv", _O(Vertex3dv) },
 700    { "glVertex3f", _O(Vertex3f) },
 701    { "glVertex3fv", _O(Vertex3fv) },
 702    { "glVertex3i", _O(Vertex3i) },
 703    { "glVertex3iv", _O(Vertex3iv) },
 704    { "glVertex3s", _O(Vertex3s) },
 705    { "glVertex3sv", _O(Vertex3sv) },
 706    { "glVertex4d", _O(Vertex4d) },
 707    { "glVertex4dv", _O(Vertex4dv) },
 708    { "glVertex4f", _O(Vertex4f) },
 709    { "glVertex4fv", _O(Vertex4fv) },
 710    { "glVertex4i", _O(Vertex4i) },
 711    { "glVertex4iv", _O(Vertex4iv) },
 712    { "glVertex4s", _O(Vertex4s) },
 713    { "glVertex4sv", _O(Vertex4sv) },
 714    { "glClipPlane", _O(ClipPlane) },
 715    { "glColorMaterial", _O(ColorMaterial) },
 716    { "glCullFace", _O(CullFace) },
 717    { "glFogf", _O(Fogf) },
 718    { "glFogfv", _O(Fogfv) },
 719    { "glFogi", _O(Fogi) },
 720    { "glFogiv", _O(Fogiv) },
 721    { "glFrontFace", _O(FrontFace) },
 722    { "glHint", _O(Hint) },
 723    { "glLightf", _O(Lightf) },
 724    { "glLightfv", _O(Lightfv) },
 725    { "glLighti", _O(Lighti) },
 726    { "glLightiv", _O(Lightiv) },
 727    { "glLightModelf", _O(LightModelf) },
 728    { "glLightModelfv", _O(LightModelfv) },
 729    { "glLightModeli", _O(LightModeli) },
 730    { "glLightModeliv", _O(LightModeliv) },
 731    { "glLineStipple", _O(LineStipple) },
 732    { "glLineWidth", _O(LineWidth) },
 733    { "glMaterialf", _O(Materialf) },
 734    { "glMaterialfv", _O(Materialfv) },
 735    { "glMateriali", _O(Materiali) },
 736    { "glMaterialiv", _O(Materialiv) },
 737    { "glPointSize", _O(PointSize) },
 738    { "glPolygonMode", _O(PolygonMode) },
 739    { "glPolygonStipple", _O(PolygonStipple) },
 740    { "glScissor", _O(Scissor) },
 741    { "glShadeModel", _O(ShadeModel) },
 742    { "glTexParameterf", _O(TexParameterf) },
 743    { "glTexParameterfv", _O(TexParameterfv) },
 744    { "glTexParameteri", _O(TexParameteri) },
 745    { "glTexParameteriv", _O(TexParameteriv) },
 746    { "glTexImage1D", _O(TexImage1D) },
 747    { "glTexImage2D", _O(TexImage2D) },
 748    { "glTexEnvf", _O(TexEnvf) },
 749    { "glTexEnvfv", _O(TexEnvfv) },
 750    { "glTexEnvi", _O(TexEnvi) },
 751    { "glTexEnviv", _O(TexEnviv) },
 752    { "glTexGend", _O(TexGend) },
 753    { "glTexGendv", _O(TexGendv) },
 754    { "glTexGenf", _O(TexGenf) },
 755    { "glTexGenfv", _O(TexGenfv) },
 756    { "glTexGeni", _O(TexGeni) },
 757    { "glTexGeniv", _O(TexGeniv) },
 758    { "glFeedbackBuffer", _O(FeedbackBuffer) },
 759    { "glSelectBuffer", _O(SelectBuffer) },
 760    { "glRenderMode", _O(RenderMode) },
 761    { "glInitNames", _O(InitNames) },
 762    { "glLoadName", _O(LoadName) },
 763    { "glPassThrough", _O(PassThrough) },
 764    { "glPopName", _O(PopName) },
 765    { "glPushName", _O(PushName) },
 766    { "glDrawBuffer", _O(DrawBuffer) },
 767    { "glClear", _O(Clear) },
 768    { "glClearAccum", _O(ClearAccum) },
 769    { "glClearIndex", _O(ClearIndex) },
 770    { "glClearColor", _O(ClearColor) },
 771    { "glClearStencil", _O(ClearStencil) },
 772    { "glClearDepth", _O(ClearDepth) },
 773    { "glStencilMask", _O(StencilMask) },
 774    { "glColorMask", _O(ColorMask) },
 775    { "glDepthMask", _O(DepthMask) },
 776    { "glIndexMask", _O(IndexMask) },
 777    { "glAccum", _O(Accum) },
 778    { "glDisable", _O(Disable) },
 779    { "glEnable", _O(Enable) },
 780    { "glFinish", _O(Finish) },
 781    { "glFlush", _O(Flush) },
 782    { "glPopAttrib", _O(PopAttrib) },
 783    { "glPushAttrib", _O(PushAttrib) },
 784    { "glMap1d", _O(Map1d) },
 785    { "glMap1f", _O(Map1f) },
 786    { "glMap2d", _O(Map2d) },
 787    { "glMap2f", _O(Map2f) },
 788    { "glMapGrid1d", _O(MapGrid1d) },
 789    { "glMapGrid1f", _O(MapGrid1f) },
 790    { "glMapGrid2d", _O(MapGrid2d) },
 791    { "glMapGrid2f", _O(MapGrid2f) },
 792    { "glEvalCoord1d", _O(EvalCoord1d) },
 793    { "glEvalCoord1dv", _O(EvalCoord1dv) },
 794    { "glEvalCoord1f", _O(EvalCoord1f) },
 795    { "glEvalCoord1fv", _O(EvalCoord1fv) },
 796    { "glEvalCoord2d", _O(EvalCoord2d) },
 797    { "glEvalCoord2dv", _O(EvalCoord2dv) },
 798    { "glEvalCoord2f", _O(EvalCoord2f) },
 799    { "glEvalCoord2fv", _O(EvalCoord2fv) },
 800    { "glEvalMesh1", _O(EvalMesh1) },
 801    { "glEvalPoint1", _O(EvalPoint1) },
 802    { "glEvalMesh2", _O(EvalMesh2) },
 803    { "glEvalPoint2", _O(EvalPoint2) },
 804    { "glAlphaFunc", _O(AlphaFunc) },
 805    { "glBlendFunc", _O(BlendFunc) },
 806    { "glLogicOp", _O(LogicOp) },
 807    { "glStencilFunc", _O(StencilFunc) },
 808    { "glStencilOp", _O(StencilOp) },
 809    { "glDepthFunc", _O(DepthFunc) },
 810    { "glPixelZoom", _O(PixelZoom) },
 811    { "glPixelTransferf", _O(PixelTransferf) },
 812    { "glPixelTransferi", _O(PixelTransferi) },
 813    { "glPixelStoref", _O(PixelStoref) },
 814    { "glPixelStorei", _O(PixelStorei) },
 815    { "glPixelMapfv", _O(PixelMapfv) },
 816    { "glPixelMapuiv", _O(PixelMapuiv) },
 817    { "glPixelMapusv", _O(PixelMapusv) },
 818    { "glReadBuffer", _O(ReadBuffer) },
 819    { "glCopyPixels", _O(CopyPixels) },
 820    { "glReadPixels", _O(ReadPixels) },
 821    { "glDrawPixels", _O(DrawPixels) },
 822    { "glGetBooleanv", _O(GetBooleanv) },
 823    { "glGetClipPlane", _O(GetClipPlane) },
 824    { "glGetDoublev", _O(GetDoublev) },
 825    { "glGetError", _O(GetError) },
 826    { "glGetFloatv", _O(GetFloatv) },
 827    { "glGetIntegerv", _O(GetIntegerv) },
 828    { "glGetLightfv", _O(GetLightfv) },
 829    { "glGetLightiv", _O(GetLightiv) },
 830    { "glGetMapdv", _O(GetMapdv) },
 831    { "glGetMapfv", _O(GetMapfv) },
 832    { "glGetMapiv", _O(GetMapiv) },
 833    { "glGetMaterialfv", _O(GetMaterialfv) },
 834    { "glGetMaterialiv", _O(GetMaterialiv) },
 835    { "glGetPixelMapfv", _O(GetPixelMapfv) },
 836    { "glGetPixelMapuiv", _O(GetPixelMapuiv) },
 837    { "glGetPixelMapusv", _O(GetPixelMapusv) },
 838    { "glGetPolygonStipple", _O(GetPolygonStipple) },
 839    { "glGetString", _O(GetString) },
 840    { "glGetTexEnvfv", _O(GetTexEnvfv) },
 841    { "glGetTexEnviv", _O(GetTexEnviv) },
 842    { "glGetTexGendv", _O(GetTexGendv) },
 843    { "glGetTexGenfv", _O(GetTexGenfv) },
 844    { "glGetTexGeniv", _O(GetTexGeniv) },
 845    { "glGetTexImage", _O(GetTexImage) },
 846    { "glGetTexParameterfv", _O(GetTexParameterfv) },
 847    { "glGetTexParameteriv", _O(GetTexParameteriv) },
 848    { "glGetTexLevelParameterfv", _O(GetTexLevelParameterfv) },
 849    { "glGetTexLevelParameteriv", _O(GetTexLevelParameteriv) },
 850    { "glIsEnabled", _O(IsEnabled) },
 851    { "glIsList", _O(IsList) },
 852    { "glDepthRange", _O(DepthRange) },
 853    { "glFrustum", _O(Frustum) },
 854    { "glLoadIdentity", _O(LoadIdentity) },
 855    { "glLoadMatrixf", _O(LoadMatrixf) },
 856    { "glLoadMatrixd", _O(LoadMatrixd) },
 857    { "glMatrixMode", _O(MatrixMode) },
 858    { "glMultMatrixf", _O(MultMatrixf) },
 859    { "glMultMatrixd", _O(MultMatrixd) },
 860    { "glOrtho", _O(Ortho) },
 861    { "glPopMatrix", _O(PopMatrix) },
 862    { "glPushMatrix", _O(PushMatrix) },
 863    { "glRotated", _O(Rotated) },
 864    { "glRotatef", _O(Rotatef) },
 865    { "glScaled", _O(Scaled) },
 866    { "glScalef", _O(Scalef) },
 867    { "glTranslated", _O(Translated) },
 868    { "glTranslatef", _O(Translatef) },
 869    { "glViewport", _O(Viewport) },
 870    { "glArrayElement", _O(ArrayElement) },
 871    { "glBindTexture", _O(BindTexture) },
 872    { "glColorPointer", _O(ColorPointer) },
 873    { "glDisableClientState", _O(DisableClientState) },
 874    { "glDrawArrays", _O(DrawArrays) },
 875    { "glDrawElements", _O(DrawElements) },
 876    { "glEdgeFlagPointer", _O(EdgeFlagPointer) },
 877    { "glEnableClientState", _O(EnableClientState) },
 878    { "glIndexPointer", _O(IndexPointer) },
 879    { "glIndexub", _O(Indexub) },
 880    { "glIndexubv", _O(Indexubv) },
 881    { "glInterleavedArrays", _O(InterleavedArrays) },
 882    { "glNormalPointer", _O(NormalPointer) },
 883    { "glPolygonOffset", _O(PolygonOffset) },
 884    { "glTexCoordPointer", _O(TexCoordPointer) },
 885    { "glVertexPointer", _O(VertexPointer) },
 886    { "glAreTexturesResident", _O(AreTexturesResident) },
 887    { "glCopyTexImage1D", _O(CopyTexImage1D) },
 888    { "glCopyTexImage2D", _O(CopyTexImage2D) },
 889    { "glCopyTexSubImage1D", _O(CopyTexSubImage1D) },
 890    { "glCopyTexSubImage2D", _O(CopyTexSubImage2D) },
 891    { "glDeleteTextures", _O(DeleteTextures) },
 892    { "glGenTextures", _O(GenTextures) },
 893    { "glGetPointerv", _O(GetPointerv) },
 894    { "glIsTexture", _O(IsTexture) },
 895    { "glPrioritizeTextures", _O(PrioritizeTextures) },
 896    { "glTexSubImage1D", _O(TexSubImage1D) },
 897    { "glTexSubImage2D", _O(TexSubImage2D) },
 898    { "glPopClientAttrib", _O(PopClientAttrib) },
 899    { "glPushClientAttrib", _O(PushClientAttrib) },
 900    { "glBlendColor", _O(BlendColor) },
 901    { "glBlendEquation", _O(BlendEquation) },
 902    { "glDrawRangeElements", _O(DrawRangeElements) },
 903    { "glColorTable", _O(ColorTable) },
 904    { "glColorTableParameterfv", _O(ColorTableParameterfv) },
 905    { "glColorTableParameteriv", _O(ColorTableParameteriv) },
 906    { "glCopyColorTable", _O(CopyColorTable) },
 907    { "glGetColorTable", _O(GetColorTable) },
 908    { "glGetColorTableParameterfv", _O(GetColorTableParameterfv) },
 909    { "glGetColorTableParameteriv", _O(GetColorTableParameteriv) },
 910    { "glColorSubTable", _O(ColorSubTable) },
 911    { "glCopyColorSubTable", _O(CopyColorSubTable) },
 912    { "glConvolutionFilter1D", _O(ConvolutionFilter1D) },
 913    { "glConvolutionFilter2D", _O(ConvolutionFilter2D) },
 914    { "glConvolutionParameterf", _O(ConvolutionParameterf) },
 915    { "glConvolutionParameterfv", _O(ConvolutionParameterfv) },
 916    { "glConvolutionParameteri", _O(ConvolutionParameteri) },
 917    { "glConvolutionParameteriv", _O(ConvolutionParameteriv) },
 918    { "glCopyConvolutionFilter1D", _O(CopyConvolutionFilter1D) },
 919    { "glCopyConvolutionFilter2D", _O(CopyConvolutionFilter2D) },
 920    { "glGetConvolutionFilter", _O(GetConvolutionFilter) },
 921    { "glGetConvolutionParameterfv", _O(GetConvolutionParameterfv) },
 922    { "glGetConvolutionParameteriv", _O(GetConvolutionParameteriv) },
 923    { "glGetSeparableFilter", _O(GetSeparableFilter) },
 924    { "glSeparableFilter2D", _O(SeparableFilter2D) },
 925    { "glGetHistogram", _O(GetHistogram) },
 926    { "glGetHistogramParameterfv", _O(GetHistogramParameterfv) },
 927    { "glGetHistogramParameteriv", _O(GetHistogramParameteriv) },
 928    { "glGetMinmax", _O(GetMinmax) },
 929    { "glGetMinmaxParameterfv", _O(GetMinmaxParameterfv) },
 930    { "glGetMinmaxParameteriv", _O(GetMinmaxParameteriv) },
 931    { "glHistogram", _O(Histogram) },
 932    { "glMinmax", _O(Minmax) },
 933    { "glResetHistogram", _O(ResetHistogram) },
 934    { "glResetMinmax", _O(ResetMinmax) },
 935    { "glTexImage3D", _O(TexImage3D) },
 936    { "glTexSubImage3D", _O(TexSubImage3D) },
 937    { "glCopyTexSubImage3D", _O(CopyTexSubImage3D) },
 938    { "glActiveTexture", _O(ActiveTexture) },
 939    { "glClientActiveTexture", _O(ClientActiveTexture) },
 940    { "glMultiTexCoord1d", _O(MultiTexCoord1d) },
 941    { "glMultiTexCoord1dv", _O(MultiTexCoord1dv) },
 942    { "glMultiTexCoord1fARB", _O(MultiTexCoord1fARB) },
 943    { "glMultiTexCoord1fvARB", _O(MultiTexCoord1fvARB) },
 944    { "glMultiTexCoord1i", _O(MultiTexCoord1i) },
 945    { "glMultiTexCoord1iv", _O(MultiTexCoord1iv) },
 946    { "glMultiTexCoord1s", _O(MultiTexCoord1s) },
 947    { "glMultiTexCoord1sv", _O(MultiTexCoord1sv) },
 948    { "glMultiTexCoord2d", _O(MultiTexCoord2d) },
 949    { "glMultiTexCoord2dv", _O(MultiTexCoord2dv) },
 950    { "glMultiTexCoord2fARB", _O(MultiTexCoord2fARB) },
 951    { "glMultiTexCoord2fvARB", _O(MultiTexCoord2fvARB) },
 952    { "glMultiTexCoord2i", _O(MultiTexCoord2i) },
 953    { "glMultiTexCoord2iv", _O(MultiTexCoord2iv) },
 954    { "glMultiTexCoord2s", _O(MultiTexCoord2s) },
 955    { "glMultiTexCoord2sv", _O(MultiTexCoord2sv) },
 956    { "glMultiTexCoord3d", _O(MultiTexCoord3d) },
 957    { "glMultiTexCoord3dv", _O(MultiTexCoord3dv) },
 958    { "glMultiTexCoord3fARB", _O(MultiTexCoord3fARB) },
 959    { "glMultiTexCoord3fvARB", _O(MultiTexCoord3fvARB) },
 960    { "glMultiTexCoord3i", _O(MultiTexCoord3i) },
 961    { "glMultiTexCoord3iv", _O(MultiTexCoord3iv) },
 962    { "glMultiTexCoord3s", _O(MultiTexCoord3s) },
 963    { "glMultiTexCoord3sv", _O(MultiTexCoord3sv) },
 964    { "glMultiTexCoord4d", _O(MultiTexCoord4d) },
 965    { "glMultiTexCoord4dv", _O(MultiTexCoord4dv) },
 966    { "glMultiTexCoord4fARB", _O(MultiTexCoord4fARB) },
 967    { "glMultiTexCoord4fvARB", _O(MultiTexCoord4fvARB) },
 968    { "glMultiTexCoord4i", _O(MultiTexCoord4i) },
 969    { "glMultiTexCoord4iv", _O(MultiTexCoord4iv) },
 970    { "glMultiTexCoord4s", _O(MultiTexCoord4s) },
 971    { "glMultiTexCoord4sv", _O(MultiTexCoord4sv) },
 972    { "glAttachShader", _O(AttachShader) },
 973    { "glCreateProgram", _O(CreateProgram) },
 974    { "glCreateShader", _O(CreateShader) },
 975    { "glDeleteProgram", _O(DeleteProgram) },
 976    { "glDeleteShader", _O(DeleteShader) },
 977    { "glDetachShader", _O(DetachShader) },
 978    { "glGetAttachedShaders", _O(GetAttachedShaders) },
 979    { "glGetProgramInfoLog", _O(GetProgramInfoLog) },
 980    { "glGetProgramiv", _O(GetProgramiv) },
 981    { "glGetShaderInfoLog", _O(GetShaderInfoLog) },
 982    { "glGetShaderiv", _O(GetShaderiv) },
 983    { "glIsProgram", _O(IsProgram) },
 984    { "glIsShader", _O(IsShader) },
 985    { "glStencilFuncSeparate", _O(StencilFuncSeparate) },
 986    { "glStencilMaskSeparate", _O(StencilMaskSeparate) },
 987    { "glStencilOpSeparate", _O(StencilOpSeparate) },
 988    { "glUniformMatrix2x3fv", _O(UniformMatrix2x3fv) },
 989    { "glUniformMatrix2x4fv", _O(UniformMatrix2x4fv) },
 990    { "glUniformMatrix3x2fv", _O(UniformMatrix3x2fv) },
 991    { "glUniformMatrix3x4fv", _O(UniformMatrix3x4fv) },
 992    { "glUniformMatrix4x2fv", _O(UniformMatrix4x2fv) },
 993    { "glUniformMatrix4x3fv", _O(UniformMatrix4x3fv) },
 994    { "glClearBufferfi", _O(ClearBufferfi) },
 995    { "glClearBufferfv", _O(ClearBufferfv) },
 996    { "glClearBufferiv", _O(ClearBufferiv) },
 997    { "glClearBufferuiv", _O(ClearBufferuiv) },
 998    { "glGetStringi", _O(GetStringi) },
 999    { "glFramebufferTexture", _O(FramebufferTexture) },
1000    { "glGetBufferParameteri64v", _O(GetBufferParameteri64v) },
1001    { "glGetInteger64i_v", _O(GetInteger64i_v) },
1002    { "glLoadTransposeMatrixd", _O(LoadTransposeMatrixd) },
1003    { "glLoadTransposeMatrixf", _O(LoadTransposeMatrixf) },
1004    { "glMultTransposeMatrixd", _O(MultTransposeMatrixd) },
1005    { "glMultTransposeMatrixf", _O(MultTransposeMatrixf) },
1006    { "glSampleCoverage", _O(SampleCoverage) },
1007    { "glCompressedTexImage1D", _O(CompressedTexImage1D) },
1008    { "glCompressedTexImage2D", _O(CompressedTexImage2D) },
1009    { "glCompressedTexImage3D", _O(CompressedTexImage3D) },
1010    { "glCompressedTexSubImage1D", _O(CompressedTexSubImage1D) },
1011    { "glCompressedTexSubImage2D", _O(CompressedTexSubImage2D) },
1012    { "glCompressedTexSubImage3D", _O(CompressedTexSubImage3D) },
1013    { "glGetCompressedTexImage", _O(GetCompressedTexImage) },
1014    { "glDisableVertexAttribArray", _O(DisableVertexAttribArray) },
1015    { "glEnableVertexAttribArray", _O(EnableVertexAttribArray) },
1016    { "glGetProgramEnvParameterdvARB", _O(GetProgramEnvParameterdvARB) },
1017    { "glGetProgramEnvParameterfvARB", _O(GetProgramEnvParameterfvARB) },
1018    { "glGetProgramLocalParameterdvARB", _O(GetProgramLocalParameterdvARB) },
1019    { "glGetProgramLocalParameterfvARB", _O(GetProgramLocalParameterfvARB) },
1020    { "glGetProgramStringARB", _O(GetProgramStringARB) },
1021    { "glGetProgramivARB", _O(GetProgramivARB) },
1022    { "glGetVertexAttribdv", _O(GetVertexAttribdv) },
1023    { "glGetVertexAttribfv", _O(GetVertexAttribfv) },
1024    { "glGetVertexAttribiv", _O(GetVertexAttribiv) },
1025    { "glProgramEnvParameter4dARB", _O(ProgramEnvParameter4dARB) },
1026    { "glProgramEnvParameter4dvARB", _O(ProgramEnvParameter4dvARB) },
1027    { "glProgramEnvParameter4fARB", _O(ProgramEnvParameter4fARB) },
1028    { "glProgramEnvParameter4fvARB", _O(ProgramEnvParameter4fvARB) },
1029    { "glProgramLocalParameter4dARB", _O(ProgramLocalParameter4dARB) },
1030    { "glProgramLocalParameter4dvARB", _O(ProgramLocalParameter4dvARB) },
1031    { "glProgramLocalParameter4fARB", _O(ProgramLocalParameter4fARB) },
1032    { "glProgramLocalParameter4fvARB", _O(ProgramLocalParameter4fvARB) },
1033    { "glProgramStringARB", _O(ProgramStringARB) },
1034    { "glVertexAttrib1d", _O(VertexAttrib1d) },
1035    { "glVertexAttrib1dv", _O(VertexAttrib1dv) },
1036    { "glVertexAttrib1fARB", _O(VertexAttrib1fARB) },
1037    { "glVertexAttrib1fvARB", _O(VertexAttrib1fvARB) },
1038    { "glVertexAttrib1s", _O(VertexAttrib1s) },
1039    { "glVertexAttrib1sv", _O(VertexAttrib1sv) },
1040    { "glVertexAttrib2d", _O(VertexAttrib2d) },
1041    { "glVertexAttrib2dv", _O(VertexAttrib2dv) },
1042    { "glVertexAttrib2fARB", _O(VertexAttrib2fARB) },
1043    { "glVertexAttrib2fvARB", _O(VertexAttrib2fvARB) },
1044    { "glVertexAttrib2s", _O(VertexAttrib2s) },
1045    { "glVertexAttrib2sv", _O(VertexAttrib2sv) },
1046    { "glVertexAttrib3d", _O(VertexAttrib3d) },
1047    { "glVertexAttrib3dv", _O(VertexAttrib3dv) },
1048    { "glVertexAttrib3fARB", _O(VertexAttrib3fARB) },
1049    { "glVertexAttrib3fvARB", _O(VertexAttrib3fvARB) },
1050    { "glVertexAttrib3s", _O(VertexAttrib3s) },
1051    { "glVertexAttrib3sv", _O(VertexAttrib3sv) },
1052    { "glVertexAttrib4Nbv", _O(VertexAttrib4Nbv) },
1053    { "glVertexAttrib4Niv", _O(VertexAttrib4Niv) },
1054    { "glVertexAttrib4Nsv", _O(VertexAttrib4Nsv) },
1055    { "glVertexAttrib4Nub", _O(VertexAttrib4Nub) },
1056    { "glVertexAttrib4Nubv", _O(VertexAttrib4Nubv) },
1057    { "glVertexAttrib4Nuiv", _O(VertexAttrib4Nuiv) },
1058    { "glVertexAttrib4Nusv", _O(VertexAttrib4Nusv) },
1059    { "glVertexAttrib4bv", _O(VertexAttrib4bv) },
1060    { "glVertexAttrib4d", _O(VertexAttrib4d) },
1061    { "glVertexAttrib4dv", _O(VertexAttrib4dv) },
1062    { "glVertexAttrib4fARB", _O(VertexAttrib4fARB) },
1063    { "glVertexAttrib4fvARB", _O(VertexAttrib4fvARB) },
1064    { "glVertexAttrib4iv", _O(VertexAttrib4iv) },
1065    { "glVertexAttrib4s", _O(VertexAttrib4s) },
1066    { "glVertexAttrib4sv", _O(VertexAttrib4sv) },
1067    { "glVertexAttrib4ubv", _O(VertexAttrib4ubv) },
1068    { "glVertexAttrib4uiv", _O(VertexAttrib4uiv) },
1069    { "glVertexAttrib4usv", _O(VertexAttrib4usv) },
1070    { "glVertexAttribPointer", _O(VertexAttribPointer) },
1071    { "glBindBuffer", _O(BindBuffer) },
1072    { "glBufferData", _O(BufferData) },
1073    { "glBufferSubData", _O(BufferSubData) },
1074    { "glDeleteBuffers", _O(DeleteBuffers) },
1075    { "glGenBuffers", _O(GenBuffers) },
1076    { "glGetBufferParameteriv", _O(GetBufferParameteriv) },
1077    { "glGetBufferPointerv", _O(GetBufferPointerv) },
1078    { "glGetBufferSubData", _O(GetBufferSubData) },
1079    { "glIsBuffer", _O(IsBuffer) },
1080    { "glMapBuffer", _O(MapBuffer) },
1081    { "glUnmapBuffer", _O(UnmapBuffer) },
1082    { "glBeginQuery", _O(BeginQuery) },
1083    { "glDeleteQueries", _O(DeleteQueries) },
1084    { "glEndQuery", _O(EndQuery) },
1085    { "glGenQueries", _O(GenQueries) },
1086    { "glGetQueryObjectiv", _O(GetQueryObjectiv) },
1087    { "glGetQueryObjectuiv", _O(GetQueryObjectuiv) },
1088    { "glGetQueryiv", _O(GetQueryiv) },
1089    { "glIsQuery", _O(IsQuery) },
1090    { "glAttachObjectARB", _O(AttachObjectARB) },
1091    { "glCompileShader", _O(CompileShader) },
1092    { "glCreateProgramObjectARB", _O(CreateProgramObjectARB) },
1093    { "glCreateShaderObjectARB", _O(CreateShaderObjectARB) },
1094    { "glDeleteObjectARB", _O(DeleteObjectARB) },
1095    { "glDetachObjectARB", _O(DetachObjectARB) },
1096    { "glGetActiveUniform", _O(GetActiveUniform) },
1097    { "glGetAttachedObjectsARB", _O(GetAttachedObjectsARB) },
1098    { "glGetHandleARB", _O(GetHandleARB) },
1099    { "glGetInfoLogARB", _O(GetInfoLogARB) },
1100    { "glGetObjectParameterfvARB", _O(GetObjectParameterfvARB) },
1101    { "glGetObjectParameterivARB", _O(GetObjectParameterivARB) },
1102    { "glGetShaderSource", _O(GetShaderSource) },
1103    { "glGetUniformLocation", _O(GetUniformLocation) },
1104    { "glGetUniformfv", _O(GetUniformfv) },
1105    { "glGetUniformiv", _O(GetUniformiv) },
1106    { "glLinkProgram", _O(LinkProgram) },
1107    { "glShaderSource", _O(ShaderSource) },
1108    { "glUniform1f", _O(Uniform1f) },
1109    { "glUniform1fv", _O(Uniform1fv) },
1110    { "glUniform1i", _O(Uniform1i) },
1111    { "glUniform1iv", _O(Uniform1iv) },
1112    { "glUniform2f", _O(Uniform2f) },
1113    { "glUniform2fv", _O(Uniform2fv) },
1114    { "glUniform2i", _O(Uniform2i) },
1115    { "glUniform2iv", _O(Uniform2iv) },
1116    { "glUniform3f", _O(Uniform3f) },
1117    { "glUniform3fv", _O(Uniform3fv) },
1118    { "glUniform3i", _O(Uniform3i) },
1119    { "glUniform3iv", _O(Uniform3iv) },
1120    { "glUniform4f", _O(Uniform4f) },
1121    { "glUniform4fv", _O(Uniform4fv) },
1122    { "glUniform4i", _O(Uniform4i) },
1123    { "glUniform4iv", _O(Uniform4iv) },
1124    { "glUniformMatrix2fv", _O(UniformMatrix2fv) },
1125    { "glUniformMatrix3fv", _O(UniformMatrix3fv) },
1126    { "glUniformMatrix4fv", _O(UniformMatrix4fv) },
1127    { "glUseProgram", _O(UseProgram) },
1128    { "glValidateProgram", _O(ValidateProgram) },
1129    { "glBindAttribLocation", _O(BindAttribLocation) },
1130    { "glGetActiveAttrib", _O(GetActiveAttrib) },
1131    { "glGetAttribLocation", _O(GetAttribLocation) },
1132    { "glDrawBuffers", _O(DrawBuffers) },
1133    { "glClampColor", _O(ClampColor) },
1134    { "glDrawArraysInstancedARB", _O(DrawArraysInstancedARB) },
1135    { "glDrawElementsInstancedARB", _O(DrawElementsInstancedARB) },
1136    { "glRenderbufferStorageMultisample", _O(RenderbufferStorageMultisample) },
1137    { "glFramebufferTexture", _O(FramebufferTexture) },
1138    { "glProgramParameteri", _O(ProgramParameteri) },
1139    { "glVertexAttribDivisor", _O(VertexAttribDivisor) },
1140    { "glFlushMappedBufferRange", _O(FlushMappedBufferRange) },
1141    { "glMapBufferRange", _O(MapBufferRange) },
1142    { "glTexBuffer", _O(TexBuffer) },
1143    { "glBindVertexArray", _O(BindVertexArray) },
1144    { "glGenVertexArrays", _O(GenVertexArrays) },
1145    { "glCopyBufferSubData", _O(CopyBufferSubData) },
1146    { "glClientWaitSync", _O(ClientWaitSync) },
1147    { "glDeleteSync", _O(DeleteSync) },
1148    { "glFenceSync", _O(FenceSync) },
1149    { "glGetInteger64v", _O(GetInteger64v) },
1150    { "glGetSynciv", _O(GetSynciv) },
1151    { "glIsSync", _O(IsSync) },
1152    { "glWaitSync", _O(WaitSync) },
1153    { "glDrawElementsBaseVertex", _O(DrawElementsBaseVertex) },
1154    { "glDrawElementsInstancedBaseVertex", _O(DrawElementsInstancedBaseVertex) },
1155    { "glDrawRangeElementsBaseVertex", _O(DrawRangeElementsBaseVertex) },
1156    { "glMultiDrawElementsBaseVertex", _O(MultiDrawElementsBaseVertex) },
1157    { "glBlendEquationSeparateiARB", _O(BlendEquationSeparateiARB) },
1158    { "glBlendEquationiARB", _O(BlendEquationiARB) },
1159    { "glBlendFuncSeparateiARB", _O(BlendFuncSeparateiARB) },
1160    { "glBlendFunciARB", _O(BlendFunciARB) },
1161    { "glBindFragDataLocationIndexed", _O(BindFragDataLocationIndexed) },
1162    { "glGetFragDataIndex", _O(GetFragDataIndex) },
1163    { "glBindSampler", _O(BindSampler) },
1164    { "glDeleteSamplers", _O(DeleteSamplers) },
1165    { "glGenSamplers", _O(GenSamplers) },
1166    { "glGetSamplerParameterIiv", _O(GetSamplerParameterIiv) },
1167    { "glGetSamplerParameterIuiv", _O(GetSamplerParameterIuiv) },
1168    { "glGetSamplerParameterfv", _O(GetSamplerParameterfv) },
1169    { "glGetSamplerParameteriv", _O(GetSamplerParameteriv) },
1170    { "glIsSampler", _O(IsSampler) },
1171    { "glSamplerParameterIiv", _O(SamplerParameterIiv) },
1172    { "glSamplerParameterIuiv", _O(SamplerParameterIuiv) },
1173    { "glSamplerParameterf", _O(SamplerParameterf) },
1174    { "glSamplerParameterfv", _O(SamplerParameterfv) },
1175    { "glSamplerParameteri", _O(SamplerParameteri) },
1176    { "glSamplerParameteriv", _O(SamplerParameteriv) },
1177    { "glColorP3ui", _O(ColorP3ui) },
1178    { "glColorP3uiv", _O(ColorP3uiv) },
1179    { "glColorP4ui", _O(ColorP4ui) },
1180    { "glColorP4uiv", _O(ColorP4uiv) },
1181    { "glMultiTexCoordP1ui", _O(MultiTexCoordP1ui) },
1182    { "glMultiTexCoordP1uiv", _O(MultiTexCoordP1uiv) },
1183    { "glMultiTexCoordP2ui", _O(MultiTexCoordP2ui) },
1184    { "glMultiTexCoordP2uiv", _O(MultiTexCoordP2uiv) },
1185    { "glMultiTexCoordP3ui", _O(MultiTexCoordP3ui) },
1186    { "glMultiTexCoordP3uiv", _O(MultiTexCoordP3uiv) },
1187    { "glMultiTexCoordP4ui", _O(MultiTexCoordP4ui) },
1188    { "glMultiTexCoordP4uiv", _O(MultiTexCoordP4uiv) },
1189    { "glNormalP3ui", _O(NormalP3ui) },
1190    { "glNormalP3uiv", _O(NormalP3uiv) },
1191    { "glSecondaryColorP3ui", _O(SecondaryColorP3ui) },
1192    { "glSecondaryColorP3uiv", _O(SecondaryColorP3uiv) },
1193    { "glTexCoordP1ui", _O(TexCoordP1ui) },
1194    { "glTexCoordP1uiv", _O(TexCoordP1uiv) },
1195    { "glTexCoordP2ui", _O(TexCoordP2ui) },
1196    { "glTexCoordP2uiv", _O(TexCoordP2uiv) },
1197    { "glTexCoordP3ui", _O(TexCoordP3ui) },
1198    { "glTexCoordP3uiv", _O(TexCoordP3uiv) },
1199    { "glTexCoordP4ui", _O(TexCoordP4ui) },
1200    { "glTexCoordP4uiv", _O(TexCoordP4uiv) },
1201    { "glVertexAttribP1ui", _O(VertexAttribP1ui) },
1202    { "glVertexAttribP1uiv", _O(VertexAttribP1uiv) },
1203    { "glVertexAttribP2ui", _O(VertexAttribP2ui) },
1204    { "glVertexAttribP2uiv", _O(VertexAttribP2uiv) },
1205    { "glVertexAttribP3ui", _O(VertexAttribP3ui) },
1206    { "glVertexAttribP3uiv", _O(VertexAttribP3uiv) },
1207    { "glVertexAttribP4ui", _O(VertexAttribP4ui) },
1208    { "glVertexAttribP4uiv", _O(VertexAttribP4uiv) },
1209    { "glVertexP2ui", _O(VertexP2ui) },
1210    { "glVertexP2uiv", _O(VertexP2uiv) },
1211    { "glVertexP3ui", _O(VertexP3ui) },
1212    { "glVertexP3uiv", _O(VertexP3uiv) },
1213    { "glVertexP4ui", _O(VertexP4ui) },
1214    { "glVertexP4uiv", _O(VertexP4uiv) },
1215    { "glBindTransformFeedback", _O(BindTransformFeedback) },
1216    { "glDeleteTransformFeedbacks", _O(DeleteTransformFeedbacks) },
1217    { "glDrawTransformFeedback", _O(DrawTransformFeedback) },
1218    { "glGenTransformFeedbacks", _O(GenTransformFeedbacks) },
1219    { "glIsTransformFeedback", _O(IsTransformFeedback) },
1220    { "glPauseTransformFeedback", _O(PauseTransformFeedback) },
1221    { "glResumeTransformFeedback", _O(ResumeTransformFeedback) },
1222    { "glClearDepthf", _O(ClearDepthf) },
1223    { "glDepthRangef", _O(DepthRangef) },
1224    { "glGetShaderPrecisionFormat", _O(GetShaderPrecisionFormat) },
1225    { "glReleaseShaderCompiler", _O(ReleaseShaderCompiler) },
1226    { "glShaderBinary", _O(ShaderBinary) },
1227    { "glDebugMessageCallback", _O(DebugMessageCallback) },
1228    { "glDebugMessageControl", _O(DebugMessageControl) },
1229    { "glDebugMessageInsert", _O(DebugMessageInsert) },
1230    { "glGetDebugMessageLog", _O(GetDebugMessageLog) },
1231    { "glPushDebugGroup", _O(PushDebugGroup) },
1232    { "glPopDebugGroup", _O(PopDebugGroup) },
1233    { "glGetObjectLabel", _O(GetObjectLabel) },
1234    { "glGetObjectPtrLabel", _O(GetObjectPtrLabel) },
1235    { "glObjectLabel", _O(ObjectLabel) },
1236    { "glObjectPtrLabel", _O(ObjectPtrLabel) },
1237    { "glGetGraphicsResetStatusARB", _O(GetGraphicsResetStatusARB) },
1238    { "glGetnColorTableARB", _O(GetnColorTableARB) },
1239    { "glGetnCompressedTexImageARB", _O(GetnCompressedTexImageARB) },
1240    { "glGetnConvolutionFilterARB", _O(GetnConvolutionFilterARB) },
1241    { "glGetnHistogramARB", _O(GetnHistogramARB) },
1242    { "glGetnMapdvARB", _O(GetnMapdvARB) },
1243    { "glGetnMapfvARB", _O(GetnMapfvARB) },
1244    { "glGetnMapivARB", _O(GetnMapivARB) },
1245    { "glGetnMinmaxARB", _O(GetnMinmaxARB) },
1246    { "glGetnPixelMapfvARB", _O(GetnPixelMapfvARB) },
1247    { "glGetnPixelMapuivARB", _O(GetnPixelMapuivARB) },
1248    { "glGetnPixelMapusvARB", _O(GetnPixelMapusvARB) },
1249    { "glGetnPolygonStippleARB", _O(GetnPolygonStippleARB) },
1250    { "glGetnSeparableFilterARB", _O(GetnSeparableFilterARB) },
1251    { "glGetnTexImageARB", _O(GetnTexImageARB) },
1252    { "glGetnUniformdvARB", _O(GetnUniformdvARB) },
1253    { "glGetnUniformfvARB", _O(GetnUniformfvARB) },
1254    { "glGetnUniformivARB", _O(GetnUniformivARB) },
1255    { "glGetnUniformuivARB", _O(GetnUniformuivARB) },
1256    { "glReadnPixelsARB", _O(ReadnPixelsARB) },
1257    { "glTexStorage1D", _O(TexStorage1D) },
1258    { "glTexStorage2D", _O(TexStorage2D) },
1259    { "glTexStorage3D", _O(TexStorage3D) },
1260    { "glTextureStorage1DEXT", _O(TextureStorage1DEXT) },
1261    { "glTextureStorage2DEXT", _O(TextureStorage2DEXT) },
1262    { "glTextureStorage3DEXT", _O(TextureStorage3DEXT) },
1263    { "glSampleMaskSGIS", _O(SampleMaskSGIS) },
1264    { "glSamplePatternSGIS", _O(SamplePatternSGIS) },
1265    { "glColorPointerEXT", _O(ColorPointerEXT) },
1266    { "glEdgeFlagPointerEXT", _O(EdgeFlagPointerEXT) },
1267    { "glIndexPointerEXT", _O(IndexPointerEXT) },
1268    { "glNormalPointerEXT", _O(NormalPointerEXT) },
1269    { "glTexCoordPointerEXT", _O(TexCoordPointerEXT) },
1270    { "glVertexPointerEXT", _O(VertexPointerEXT) },
1271    { "glPointParameterf", _O(PointParameterf) },
1272    { "glPointParameterfv", _O(PointParameterfv) },
1273    { "glLockArraysEXT", _O(LockArraysEXT) },
1274    { "glUnlockArraysEXT", _O(UnlockArraysEXT) },
1275    { "glSecondaryColor3b", _O(SecondaryColor3b) },
1276    { "glSecondaryColor3bv", _O(SecondaryColor3bv) },
1277    { "glSecondaryColor3d", _O(SecondaryColor3d) },
1278    { "glSecondaryColor3dv", _O(SecondaryColor3dv) },
1279    { "glSecondaryColor3fEXT", _O(SecondaryColor3fEXT) },
1280    { "glSecondaryColor3fvEXT", _O(SecondaryColor3fvEXT) },
1281    { "glSecondaryColor3i", _O(SecondaryColor3i) },
1282    { "glSecondaryColor3iv", _O(SecondaryColor3iv) },
1283    { "glSecondaryColor3s", _O(SecondaryColor3s) },
1284    { "glSecondaryColor3sv", _O(SecondaryColor3sv) },
1285    { "glSecondaryColor3ub", _O(SecondaryColor3ub) },
1286    { "glSecondaryColor3ubv", _O(SecondaryColor3ubv) },
1287    { "glSecondaryColor3ui", _O(SecondaryColor3ui) },
1288    { "glSecondaryColor3uiv", _O(SecondaryColor3uiv) },
1289    { "glSecondaryColor3us", _O(SecondaryColor3us) },
1290    { "glSecondaryColor3usv", _O(SecondaryColor3usv) },
1291    { "glSecondaryColorPointer", _O(SecondaryColorPointer) },
1292    { "glMultiDrawArrays", _O(MultiDrawArrays) },
1293    { "glMultiDrawElementsEXT", _O(MultiDrawElementsEXT) },
1294    { "glFogCoordPointer", _O(FogCoordPointer) },
1295    { "glFogCoordd", _O(FogCoordd) },
1296    { "glFogCoorddv", _O(FogCoorddv) },
1297    { "glFogCoordfEXT", _O(FogCoordfEXT) },
1298    { "glFogCoordfvEXT", _O(FogCoordfvEXT) },
1299    { "glBlendFuncSeparate", _O(BlendFuncSeparate) },
1300    { "glResizeBuffersMESA", _O(ResizeBuffersMESA) },
1301    { "glWindowPos2d", _O(WindowPos2d) },
1302    { "glWindowPos2dv", _O(WindowPos2dv) },
1303    { "glWindowPos2f", _O(WindowPos2f) },
1304    { "glWindowPos2fv", _O(WindowPos2fv) },
1305    { "glWindowPos2i", _O(WindowPos2i) },
1306    { "glWindowPos2iv", _O(WindowPos2iv) },
1307    { "glWindowPos2s", _O(WindowPos2s) },
1308    { "glWindowPos2sv", _O(WindowPos2sv) },
1309    { "glWindowPos3d", _O(WindowPos3d) },
1310    { "glWindowPos3dv", _O(WindowPos3dv) },
1311    { "glWindowPos3f", _O(WindowPos3f) },
1312    { "glWindowPos3fv", _O(WindowPos3fv) },
1313    { "glWindowPos3i", _O(WindowPos3i) },
1314    { "glWindowPos3iv", _O(WindowPos3iv) },
1315    { "glWindowPos3s", _O(WindowPos3s) },
1316    { "glWindowPos3sv", _O(WindowPos3sv) },
1317    { "glWindowPos4dMESA", _O(WindowPos4dMESA) },
1318    { "glWindowPos4dvMESA", _O(WindowPos4dvMESA) },
1319    { "glWindowPos4fMESA", _O(WindowPos4fMESA) },
1320    { "glWindowPos4fvMESA", _O(WindowPos4fvMESA) },
1321    { "glWindowPos4iMESA", _O(WindowPos4iMESA) },
1322    { "glWindowPos4ivMESA", _O(WindowPos4ivMESA) },
1323    { "glWindowPos4sMESA", _O(WindowPos4sMESA) },
1324    { "glWindowPos4svMESA", _O(WindowPos4svMESA) },
1325    { "glMultiModeDrawArraysIBM", _O(MultiModeDrawArraysIBM) },
1326    { "glMultiModeDrawElementsIBM", _O(MultiModeDrawElementsIBM) },
1327    { "glAreProgramsResidentNV", _O(AreProgramsResidentNV) },
1328    { "glBindProgramARB", _O(BindProgramARB) },
1329    { "glDeleteProgramsARB", _O(DeleteProgramsARB) },
1330    { "glExecuteProgramNV", _O(ExecuteProgramNV) },
1331    { "glGenProgramsARB", _O(GenProgramsARB) },
1332    { "glGetProgramParameterdvNV", _O(GetProgramParameterdvNV) },
1333    { "glGetProgramParameterfvNV", _O(GetProgramParameterfvNV) },
1334    { "glGetProgramStringNV", _O(GetProgramStringNV) },
1335    { "glGetProgramivNV", _O(GetProgramivNV) },
1336    { "glGetTrackMatrixivNV", _O(GetTrackMatrixivNV) },
1337    { "glGetVertexAttribPointerv", _O(GetVertexAttribPointerv) },
1338    { "glGetVertexAttribdvNV", _O(GetVertexAttribdvNV) },
1339    { "glGetVertexAttribfvNV", _O(GetVertexAttribfvNV) },
1340    { "glGetVertexAttribivNV", _O(GetVertexAttribivNV) },
1341    { "glIsProgram", _O(IsProgram) },
1342    { "glLoadProgramNV", _O(LoadProgramNV) },
1343    { "glProgramParameters4dvNV", _O(ProgramParameters4dvNV) },
1344    { "glProgramParameters4fvNV", _O(ProgramParameters4fvNV) },
1345    { "glRequestResidentProgramsNV", _O(RequestResidentProgramsNV) },
1346    { "glTrackMatrixNV", _O(TrackMatrixNV) },
1347    { "glVertexAttrib1dNV", _O(VertexAttrib1dNV) },
1348    { "glVertexAttrib1dvNV", _O(VertexAttrib1dvNV) },
1349    { "glVertexAttrib1fNV", _O(VertexAttrib1fNV) },
1350    { "glVertexAttrib1fvNV", _O(VertexAttrib1fvNV) },
1351    { "glVertexAttrib1sNV", _O(VertexAttrib1sNV) },
1352    { "glVertexAttrib1svNV", _O(VertexAttrib1svNV) },
1353    { "glVertexAttrib2dNV", _O(VertexAttrib2dNV) },
1354    { "glVertexAttrib2dvNV", _O(VertexAttrib2dvNV) },
1355    { "glVertexAttrib2fNV", _O(VertexAttrib2fNV) },
1356    { "glVertexAttrib2fvNV", _O(VertexAttrib2fvNV) },
1357    { "glVertexAttrib2sNV", _O(VertexAttrib2sNV) },
1358    { "glVertexAttrib2svNV", _O(VertexAttrib2svNV) },
1359    { "glVertexAttrib3dNV", _O(VertexAttrib3dNV) },
1360    { "glVertexAttrib3dvNV", _O(VertexAttrib3dvNV) },
1361    { "glVertexAttrib3fNV", _O(VertexAttrib3fNV) },
1362    { "glVertexAttrib3fvNV", _O(VertexAttrib3fvNV) },
1363    { "glVertexAttrib3sNV", _O(VertexAttrib3sNV) },
1364    { "glVertexAttrib3svNV", _O(VertexAttrib3svNV) },
1365    { "glVertexAttrib4dNV", _O(VertexAttrib4dNV) },
1366    { "glVertexAttrib4dvNV", _O(VertexAttrib4dvNV) },
1367    { "glVertexAttrib4fNV", _O(VertexAttrib4fNV) },
1368    { "glVertexAttrib4fvNV", _O(VertexAttrib4fvNV) },
1369    { "glVertexAttrib4sNV", _O(VertexAttrib4sNV) },
1370    { "glVertexAttrib4svNV", _O(VertexAttrib4svNV) },
1371    { "glVertexAttrib4ubNV", _O(VertexAttrib4ubNV) },
1372    { "glVertexAttrib4ubvNV", _O(VertexAttrib4ubvNV) },
1373    { "glVertexAttribPointerNV", _O(VertexAttribPointerNV) },
1374    { "glVertexAttribs1dvNV", _O(VertexAttribs1dvNV) },
1375    { "glVertexAttribs1fvNV", _O(VertexAttribs1fvNV) },
1376    { "glVertexAttribs1svNV", _O(VertexAttribs1svNV) },
1377    { "glVertexAttribs2dvNV", _O(VertexAttribs2dvNV) },
1378    { "glVertexAttribs2fvNV", _O(VertexAttribs2fvNV) },
1379    { "glVertexAttribs2svNV", _O(VertexAttribs2svNV) },
1380    { "glVertexAttribs3dvNV", _O(VertexAttribs3dvNV) },
1381    { "glVertexAttribs3fvNV", _O(VertexAttribs3fvNV) },
1382    { "glVertexAttribs3svNV", _O(VertexAttribs3svNV) },
1383    { "glVertexAttribs4dvNV", _O(VertexAttribs4dvNV) },
1384    { "glVertexAttribs4fvNV", _O(VertexAttribs4fvNV) },
1385    { "glVertexAttribs4svNV", _O(VertexAttribs4svNV) },
1386    { "glVertexAttribs4ubvNV", _O(VertexAttribs4ubvNV) },
1387    { "glAlphaFragmentOp1ATI", _O(AlphaFragmentOp1ATI) },
1388    { "glAlphaFragmentOp2ATI", _O(AlphaFragmentOp2ATI) },
1389    { "glAlphaFragmentOp3ATI", _O(AlphaFragmentOp3ATI) },
1390    { "glBeginFragmentShaderATI", _O(BeginFragmentShaderATI) },
1391    { "glBindFragmentShaderATI", _O(BindFragmentShaderATI) },
1392    { "glColorFragmentOp1ATI", _O(ColorFragmentOp1ATI) },
1393    { "glColorFragmentOp2ATI", _O(ColorFragmentOp2ATI) },
1394    { "glColorFragmentOp3ATI", _O(ColorFragmentOp3ATI) },
1395    { "glDeleteFragmentShaderATI", _O(DeleteFragmentShaderATI) },
1396    { "glEndFragmentShaderATI", _O(EndFragmentShaderATI) },
1397    { "glGenFragmentShadersATI", _O(GenFragmentShadersATI) },
1398    { "glPassTexCoordATI", _O(PassTexCoordATI) },
1399    { "glSampleMapATI", _O(SampleMapATI) },
1400    { "glSetFragmentShaderConstantATI", _O(SetFragmentShaderConstantATI) },
1401    { "glPointParameteri", _O(PointParameteri) },
1402    { "glPointParameteriv", _O(PointParameteriv) },
1403    { "glActiveStencilFaceEXT", _O(ActiveStencilFaceEXT) },
1404    { "glDeleteVertexArrays", _O(DeleteVertexArrays) },
1405    { "glIsVertexArray", _O(IsVertexArray) },
1406    { "glGetProgramNamedParameterdvNV", _O(GetProgramNamedParameterdvNV) },
1407    { "glGetProgramNamedParameterfvNV", _O(GetProgramNamedParameterfvNV) },
1408    { "glProgramNamedParameter4dNV", _O(ProgramNamedParameter4dNV) },
1409    { "glProgramNamedParameter4dvNV", _O(ProgramNamedParameter4dvNV) },
1410    { "glProgramNamedParameter4fNV", _O(ProgramNamedParameter4fNV) },
1411    { "glProgramNamedParameter4fvNV", _O(ProgramNamedParameter4fvNV) },
1412    { "glPrimitiveRestartIndex", _O(PrimitiveRestartIndex) },
1413    { "glPrimitiveRestartNV", _O(PrimitiveRestartNV) },
1414    { "glDepthBoundsEXT", _O(DepthBoundsEXT) },
1415    { "glBlendEquationSeparate", _O(BlendEquationSeparate) },
1416    { "glBindFramebuffer", _O(BindFramebuffer) },
1417    { "glBindRenderbuffer", _O(BindRenderbuffer) },
1418    { "glCheckFramebufferStatus", _O(CheckFramebufferStatus) },
1419    { "glDeleteFramebuffers", _O(DeleteFramebuffers) },
1420    { "glDeleteRenderbuffers", _O(DeleteRenderbuffers) },
1421    { "glFramebufferRenderbuffer", _O(FramebufferRenderbuffer) },
1422    { "glFramebufferTexture1D", _O(FramebufferTexture1D) },
1423    { "glFramebufferTexture2D", _O(FramebufferTexture2D) },
1424    { "glFramebufferTexture3D", _O(FramebufferTexture3D) },
1425    { "glGenFramebuffers", _O(GenFramebuffers) },
1426    { "glGenRenderbuffers", _O(GenRenderbuffers) },
1427    { "glGenerateMipmap", _O(GenerateMipmap) },
1428    { "glGetFramebufferAttachmentParameteriv", _O(GetFramebufferAttachmentParameteriv) },
1429    { "glGetRenderbufferParameteriv", _O(GetRenderbufferParameteriv) },
1430    { "glIsFramebuffer", _O(IsFramebuffer) },
1431    { "glIsRenderbuffer", _O(IsRenderbuffer) },
1432    { "glRenderbufferStorage", _O(RenderbufferStorage) },
1433    { "glBlitFramebuffer", _O(BlitFramebuffer) },
1434    { "glBufferParameteriAPPLE", _O(BufferParameteriAPPLE) },
1435    { "glFlushMappedBufferRangeAPPLE", _O(FlushMappedBufferRangeAPPLE) },
1436    { "glBindFragDataLocation", _O(BindFragDataLocation) },
1437    { "glGetFragDataLocation", _O(GetFragDataLocation) },
1438    { "glGetUniformuiv", _O(GetUniformuiv) },
1439    { "glGetVertexAttribIiv", _O(GetVertexAttribIiv) },
1440    { "glGetVertexAttribIuiv", _O(GetVertexAttribIuiv) },
1441    { "glUniform1ui", _O(Uniform1ui) },
1442    { "glUniform1uiv", _O(Uniform1uiv) },
1443    { "glUniform2ui", _O(Uniform2ui) },
1444    { "glUniform2uiv", _O(Uniform2uiv) },
1445    { "glUniform3ui", _O(Uniform3ui) },
1446    { "glUniform3uiv", _O(Uniform3uiv) },
1447    { "glUniform4ui", _O(Uniform4ui) },
1448    { "glUniform4uiv", _O(Uniform4uiv) },
1449    { "glVertexAttribI1iEXT", _O(VertexAttribI1iEXT) },
1450    { "glVertexAttribI1iv", _O(VertexAttribI1iv) },
1451    { "glVertexAttribI1uiEXT", _O(VertexAttribI1uiEXT) },
1452    { "glVertexAttribI1uiv", _O(VertexAttribI1uiv) },
1453    { "glVertexAttribI2iEXT", _O(VertexAttribI2iEXT) },
1454    { "glVertexAttribI2ivEXT", _O(VertexAttribI2ivEXT) },
1455    { "glVertexAttribI2uiEXT", _O(VertexAttribI2uiEXT) },
1456    { "glVertexAttribI2uivEXT", _O(VertexAttribI2uivEXT) },
1457    { "glVertexAttribI3iEXT", _O(VertexAttribI3iEXT) },
1458    { "glVertexAttribI3ivEXT", _O(VertexAttribI3ivEXT) },
1459    { "glVertexAttribI3uiEXT", _O(VertexAttribI3uiEXT) },
1460    { "glVertexAttribI3uivEXT", _O(VertexAttribI3uivEXT) },
1461    { "glVertexAttribI4bv", _O(VertexAttribI4bv) },
1462    { "glVertexAttribI4iEXT", _O(VertexAttribI4iEXT) },
1463    { "glVertexAttribI4ivEXT", _O(VertexAttribI4ivEXT) },
1464    { "glVertexAttribI4sv", _O(VertexAttribI4sv) },
1465    { "glVertexAttribI4ubv", _O(VertexAttribI4ubv) },
1466    { "glVertexAttribI4uiEXT", _O(VertexAttribI4uiEXT) },
1467    { "glVertexAttribI4uivEXT", _O(VertexAttribI4uivEXT) },
1468    { "glVertexAttribI4usv", _O(VertexAttribI4usv) },
1469    { "glVertexAttribIPointer", _O(VertexAttribIPointer) },
1470    { "glFramebufferTextureLayer", _O(FramebufferTextureLayer) },
1471    { "glColorMaski", _O(ColorMaski) },
1472    { "glDisablei", _O(Disablei) },
1473    { "glEnablei", _O(Enablei) },
1474    { "glGetBooleani_v", _O(GetBooleani_v) },
1475    { "glGetIntegeri_v", _O(GetIntegeri_v) },
1476    { "glIsEnabledi", _O(IsEnabledi) },
1477    { "glClearColorIiEXT", _O(ClearColorIiEXT) },
1478    { "glClearColorIuiEXT", _O(ClearColorIuiEXT) },
1479    { "glGetTexParameterIiv", _O(GetTexParameterIiv) },
1480    { "glGetTexParameterIuiv", _O(GetTexParameterIuiv) },
1481    { "glTexParameterIiv", _O(TexParameterIiv) },
1482    { "glTexParameterIuiv", _O(TexParameterIuiv) },
1483    { "glBeginConditionalRender", _O(BeginConditionalRender) },
1484    { "glEndConditionalRender", _O(EndConditionalRender) },
1485    { "glBeginTransformFeedback", _O(BeginTransformFeedback) },
1486    { "glBindBufferBase", _O(BindBufferBase) },
1487    { "glBindBufferOffsetEXT", _O(BindBufferOffsetEXT) },
1488    { "glBindBufferRange", _O(BindBufferRange) },
1489    { "glEndTransformFeedback", _O(EndTransformFeedback) },
1490    { "glGetTransformFeedbackVarying", _O(GetTransformFeedbackVarying) },
1491    { "glTransformFeedbackVaryings", _O(TransformFeedbackVaryings) },
1492    { "glProvokingVertex", _O(ProvokingVertex) },
1493    { "glGetObjectParameterivAPPLE", _O(GetObjectParameterivAPPLE) },
1494    { "glObjectPurgeableAPPLE", _O(ObjectPurgeableAPPLE) },
1495    { "glObjectUnpurgeableAPPLE", _O(ObjectUnpurgeableAPPLE) },
1496    { "glActiveProgramEXT", _O(ActiveProgramEXT) },
1497    { "glCreateShaderProgramEXT", _O(CreateShaderProgramEXT) },
1498    { "glUseShaderProgramEXT", _O(UseShaderProgramEXT) },
1499    { "glTextureBarrierNV", _O(TextureBarrierNV) },
1500    { "glStencilFuncSeparateATI", _O(StencilFuncSeparateATI) },
1501    { "glProgramEnvParameters4fvEXT", _O(ProgramEnvParameters4fvEXT) },
1502    { "glProgramLocalParameters4fvEXT", _O(ProgramLocalParameters4fvEXT) },
1503    { "glGetQueryObjecti64v", _O(GetQueryObjecti64v) },
1504    { "glGetQueryObjectui64v", _O(GetQueryObjectui64v) },
1505    { "glEGLImageTargetRenderbufferStorageOES", _O(EGLImageTargetRenderbufferStorageOES) },
1506    { "glEGLImageTargetTexture2DOES", _O(EGLImageTargetTexture2DOES) },
1507    { NULL, 0 }
1508 };
1509
1510 #ifdef GLX_INDIRECT_RENDERING
1511 extern "C" {
1512 GLAPI GLboolean GLAPIENTRY
1513 glAreTexturesResidentEXT(GLsizei n, const GLuint *textures,
1514                          GLboolean *residences)
1515 {
1516    (void) n;
1517    (void) textures;
1518    (void) residences;
1519    return GL_FALSE;
1520 }
1521
1522 GLAPI void GLAPIENTRY
1523 glDeleteTexturesEXT(GLsizei n, const GLuint *textures)
1524 {
1525    (void) n;
1526    (void) textures;
1527 }
1528
1529 GLAPI void GLAPIENTRY
1530 glGenTexturesEXT(GLsizei n, GLuint *textures)
1531 {
1532    (void) n;
1533    (void) textures;
1534 }
1535
1536 GLAPI GLboolean GLAPIENTRY
1537 glIsTextureEXT(GLuint texture)
1538 {
1539    (void) texture;
1540    return GL_FALSE;
1541 }
1542
1543 GLAPI void GLAPIENTRY
1544 glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
1545 {
1546    (void) target;
1547    (void) format;
1548    (void) type;
1549    (void) table;
1550 }
1551
1552 GLAPI void GLAPIENTRY
1553 glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
1554 {
1555    (void) target;
1556    (void) pname;
1557    (void) params;
1558 }
1559
1560 GLAPI void GLAPIENTRY
1561 glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params)
1562 {
1563    (void) target;
1564    (void) pname;
1565    (void) params;
1566 }
1567
1568 void GLAPIENTRY
1569 gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * image)
1570 {
1571    (void) target;
1572    (void) format;
1573    (void) type;
1574    (void) image;
1575 }
1576
1577 void GLAPIENTRY
1578 gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params)
1579 {
1580    (void) target;
1581    (void) pname;
1582    (void) params;
1583 }
1584
1585 void GLAPIENTRY
1586 gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params)
1587 {
1588    (void) target;
1589    (void) pname;
1590    (void) params;
1591 }
1592
1593 void GLAPIENTRY
1594 gl_dispatch_stub_359(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)
1595 {
1596    (void) target;
1597    (void) format;
1598    (void) type;
1599    (void) row;
1600    (void) column;
1601    (void) span;
1602 }
1603
1604 void GLAPIENTRY
1605 gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
1606 {
1607    (void) target;
1608    (void) reset;
1609    (void) format;
1610    (void) type;
1611    (void) values;
1612 }
1613
1614 void GLAPIENTRY
1615 gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params)
1616 {
1617    (void) target;
1618    (void) pname;
1619    (void) params;
1620 }
1621
1622 void GLAPIENTRY
1623 gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params)
1624 {
1625    (void) target;
1626    (void) pname;
1627    (void) params;
1628 }
1629
1630 void GLAPIENTRY
1631 gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
1632 {
1633    (void) target;
1634    (void) reset;
1635    (void) format;
1636    (void) type;
1637    (void) values;
1638 }
1639
1640 void GLAPIENTRY
1641 gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params)
1642 {
1643    (void) target;
1644    (void) pname;
1645    (void) params;
1646 }
1647
1648 void GLAPIENTRY
1649 gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params)
1650 {
1651    (void) target;
1652    (void) pname;
1653    (void) params;
1654 }
1655
1656 }
1657 #endif