src/mapi/glapi/glapi_gentable.c

   1 /* DO NOT EDIT - This file generated automatically by gl_gen_table.py (from Mesa) script */
   2
   3 /*
   4  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   5  * (C) Copyright IBM Corporation 2004, 2005
   6  * (C) Copyright Apple Inc 2011
   7  * 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, sub license,
  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 (including the next
  17  * paragraph) shall be included in all copies or substantial portions of the
  18  * Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  23  * BRIAN PAUL, IBM,
  24  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  25  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  26  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30
  31 #if defined(DEBUG) && !defined(_WIN32_WCE)
  32 #include <execinfo.h>
  33 #endif
  34
  35 #include <dlfcn.h>
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38
  39 #include <GL/gl.h>
  40
  41 #include "glapi.h"
  42 #include "glapitable.h"
  43
  44 static void
  45 __glapi_gentable_NoOp(void) {
  46 #if defined(DEBUG) && !defined(_WIN32_WCE)
  47     if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
  48         const char *fstr = "Unknown";
  49         void *frames[2];
  50
  51         if(backtrace(frames, 2) == 2) {
  52             Dl_info info;
  53             dladdr(frames[1], &info);
  54             if(info.dli_sname)
  55                 fstr = info.dli_sname;
  56         }
  57
  58         fprintf(stderr, "Call to unimplemented API: %s\n", fstr);
  59     }
  60 #endif
  61 }
  62
  63 static void
  64 __glapi_gentable_set_remaining_noop(struct _glapi_table *disp) {
  65     GLuint entries = _glapi_get_dispatch_table_size();
  66     void **dispatch = (void **) disp;
  67     int i;
  68
  69     /* ISO C is annoying sometimes */
  70     union {_glapi_proc p; void *v;} p;
  71     p.p = __glapi_gentable_NoOp;
  72
  73     for(i=0; i < entries; i++)
  74         if(dispatch[i] == NULL)
  75             dispatch[i] = p.v;
  76 }
  77
  78 struct _glapi_table *
  79 _glapi_create_table_from_handle(void *handle, const char *symbol_prefix) {
  80     struct _glapi_table *disp = calloc(1, sizeof(struct _glapi_table));
  81     char symboln[512];
  82
  83     if(!disp)
  84         return NULL;
  85
  86     if(symbol_prefix == NULL)
  87         symbol_prefix = "";
  88
  89
  90     if(!disp->NewList) {
  91         void ** procp = (void **) &disp->NewList;
  92         snprintf(symboln, sizeof(symboln), "%sNewList", symbol_prefix);
  93         *procp = dlsym(handle, symboln);
  94     }
  95
  96
  97     if(!disp->EndList) {
  98         void ** procp = (void **) &disp->EndList;
  99         snprintf(symboln, sizeof(symboln), "%sEndList", symbol_prefix);
 100         *procp = dlsym(handle, symboln);
 101     }
 102
 103
 104     if(!disp->CallList) {
 105         void ** procp = (void **) &disp->CallList;
 106         snprintf(symboln, sizeof(symboln), "%sCallList", symbol_prefix);
 107         *procp = dlsym(handle, symboln);
 108     }
 109
 110
 111     if(!disp->CallLists) {
 112         void ** procp = (void **) &disp->CallLists;
 113         snprintf(symboln, sizeof(symboln), "%sCallLists", symbol_prefix);
 114         *procp = dlsym(handle, symboln);
 115     }
 116
 117
 118     if(!disp->DeleteLists) {
 119         void ** procp = (void **) &disp->DeleteLists;
 120         snprintf(symboln, sizeof(symboln), "%sDeleteLists", symbol_prefix);
 121         *procp = dlsym(handle, symboln);
 122     }
 123
 124
 125     if(!disp->GenLists) {
 126         void ** procp = (void **) &disp->GenLists;
 127         snprintf(symboln, sizeof(symboln), "%sGenLists", symbol_prefix);
 128         *procp = dlsym(handle, symboln);
 129     }
 130
 131
 132     if(!disp->ListBase) {
 133         void ** procp = (void **) &disp->ListBase;
 134         snprintf(symboln, sizeof(symboln), "%sListBase", symbol_prefix);
 135         *procp = dlsym(handle, symboln);
 136     }
 137
 138
 139     if(!disp->Begin) {
 140         void ** procp = (void **) &disp->Begin;
 141         snprintf(symboln, sizeof(symboln), "%sBegin", symbol_prefix);
 142         *procp = dlsym(handle, symboln);
 143     }
 144
 145
 146     if(!disp->Bitmap) {
 147         void ** procp = (void **) &disp->Bitmap;
 148         snprintf(symboln, sizeof(symboln), "%sBitmap", symbol_prefix);
 149         *procp = dlsym(handle, symboln);
 150     }
 151
 152
 153     if(!disp->Color3b) {
 154         void ** procp = (void **) &disp->Color3b;
 155         snprintf(symboln, sizeof(symboln), "%sColor3b", symbol_prefix);
 156         *procp = dlsym(handle, symboln);
 157     }
 158
 159
 160     if(!disp->Color3bv) {
 161         void ** procp = (void **) &disp->Color3bv;
 162         snprintf(symboln, sizeof(symboln), "%sColor3bv", symbol_prefix);
 163         *procp = dlsym(handle, symboln);
 164     }
 165
 166
 167     if(!disp->Color3d) {
 168         void ** procp = (void **) &disp->Color3d;
 169         snprintf(symboln, sizeof(symboln), "%sColor3d", symbol_prefix);
 170         *procp = dlsym(handle, symboln);
 171     }
 172
 173
 174     if(!disp->Color3dv) {
 175         void ** procp = (void **) &disp->Color3dv;
 176         snprintf(symboln, sizeof(symboln), "%sColor3dv", symbol_prefix);
 177         *procp = dlsym(handle, symboln);
 178     }
 179
 180
 181     if(!disp->Color3f) {
 182         void ** procp = (void **) &disp->Color3f;
 183         snprintf(symboln, sizeof(symboln), "%sColor3f", symbol_prefix);
 184         *procp = dlsym(handle, symboln);
 185     }
 186
 187
 188     if(!disp->Color3fv) {
 189         void ** procp = (void **) &disp->Color3fv;
 190         snprintf(symboln, sizeof(symboln), "%sColor3fv", symbol_prefix);
 191         *procp = dlsym(handle, symboln);
 192     }
 193
 194
 195     if(!disp->Color3i) {
 196         void ** procp = (void **) &disp->Color3i;
 197         snprintf(symboln, sizeof(symboln), "%sColor3i", symbol_prefix);
 198         *procp = dlsym(handle, symboln);
 199     }
 200
 201
 202     if(!disp->Color3iv) {
 203         void ** procp = (void **) &disp->Color3iv;
 204         snprintf(symboln, sizeof(symboln), "%sColor3iv", symbol_prefix);
 205         *procp = dlsym(handle, symboln);
 206     }
 207
 208
 209     if(!disp->Color3s) {
 210         void ** procp = (void **) &disp->Color3s;
 211         snprintf(symboln, sizeof(symboln), "%sColor3s", symbol_prefix);
 212         *procp = dlsym(handle, symboln);
 213     }
 214
 215
 216     if(!disp->Color3sv) {
 217         void ** procp = (void **) &disp->Color3sv;
 218         snprintf(symboln, sizeof(symboln), "%sColor3sv", symbol_prefix);
 219         *procp = dlsym(handle, symboln);
 220     }
 221
 222
 223     if(!disp->Color3ub) {
 224         void ** procp = (void **) &disp->Color3ub;
 225         snprintf(symboln, sizeof(symboln), "%sColor3ub", symbol_prefix);
 226         *procp = dlsym(handle, symboln);
 227     }
 228
 229
 230     if(!disp->Color3ubv) {
 231         void ** procp = (void **) &disp->Color3ubv;
 232         snprintf(symboln, sizeof(symboln), "%sColor3ubv", symbol_prefix);
 233         *procp = dlsym(handle, symboln);
 234     }
 235
 236
 237     if(!disp->Color3ui) {
 238         void ** procp = (void **) &disp->Color3ui;
 239         snprintf(symboln, sizeof(symboln), "%sColor3ui", symbol_prefix);
 240         *procp = dlsym(handle, symboln);
 241     }
 242
 243
 244     if(!disp->Color3uiv) {
 245         void ** procp = (void **) &disp->Color3uiv;
 246         snprintf(symboln, sizeof(symboln), "%sColor3uiv", symbol_prefix);
 247         *procp = dlsym(handle, symboln);
 248     }
 249
 250
 251     if(!disp->Color3us) {
 252         void ** procp = (void **) &disp->Color3us;
 253         snprintf(symboln, sizeof(symboln), "%sColor3us", symbol_prefix);
 254         *procp = dlsym(handle, symboln);
 255     }
 256
 257
 258     if(!disp->Color3usv) {
 259         void ** procp = (void **) &disp->Color3usv;
 260         snprintf(symboln, sizeof(symboln), "%sColor3usv", symbol_prefix);
 261         *procp = dlsym(handle, symboln);
 262     }
 263
 264
 265     if(!disp->Color4b) {
 266         void ** procp = (void **) &disp->Color4b;
 267         snprintf(symboln, sizeof(symboln), "%sColor4b", symbol_prefix);
 268         *procp = dlsym(handle, symboln);
 269     }
 270
 271
 272     if(!disp->Color4bv) {
 273         void ** procp = (void **) &disp->Color4bv;
 274         snprintf(symboln, sizeof(symboln), "%sColor4bv", symbol_prefix);
 275         *procp = dlsym(handle, symboln);
 276     }
 277
 278
 279     if(!disp->Color4d) {
 280         void ** procp = (void **) &disp->Color4d;
 281         snprintf(symboln, sizeof(symboln), "%sColor4d", symbol_prefix);
 282         *procp = dlsym(handle, symboln);
 283     }
 284
 285
 286     if(!disp->Color4dv) {
 287         void ** procp = (void **) &disp->Color4dv;
 288         snprintf(symboln, sizeof(symboln), "%sColor4dv", symbol_prefix);
 289         *procp = dlsym(handle, symboln);
 290     }
 291
 292
 293     if(!disp->Color4f) {
 294         void ** procp = (void **) &disp->Color4f;
 295         snprintf(symboln, sizeof(symboln), "%sColor4f", symbol_prefix);
 296         *procp = dlsym(handle, symboln);
 297     }
 298
 299
 300     if(!disp->Color4fv) {
 301         void ** procp = (void **) &disp->Color4fv;
 302         snprintf(symboln, sizeof(symboln), "%sColor4fv", symbol_prefix);
 303         *procp = dlsym(handle, symboln);
 304     }
 305
 306
 307     if(!disp->Color4i) {
 308         void ** procp = (void **) &disp->Color4i;
 309         snprintf(symboln, sizeof(symboln), "%sColor4i", symbol_prefix);
 310         *procp = dlsym(handle, symboln);
 311     }
 312
 313
 314     if(!disp->Color4iv) {
 315         void ** procp = (void **) &disp->Color4iv;
 316         snprintf(symboln, sizeof(symboln), "%sColor4iv", symbol_prefix);
 317         *procp = dlsym(handle, symboln);
 318     }
 319
 320
 321     if(!disp->Color4s) {
 322         void ** procp = (void **) &disp->Color4s;
 323         snprintf(symboln, sizeof(symboln), "%sColor4s", symbol_prefix);
 324         *procp = dlsym(handle, symboln);
 325     }
 326
 327
 328     if(!disp->Color4sv) {
 329         void ** procp = (void **) &disp->Color4sv;
 330         snprintf(symboln, sizeof(symboln), "%sColor4sv", symbol_prefix);
 331         *procp = dlsym(handle, symboln);
 332     }
 333
 334
 335     if(!disp->Color4ub) {
 336         void ** procp = (void **) &disp->Color4ub;
 337         snprintf(symboln, sizeof(symboln), "%sColor4ub", symbol_prefix);
 338         *procp = dlsym(handle, symboln);
 339     }
 340
 341
 342     if(!disp->Color4ubv) {
 343         void ** procp = (void **) &disp->Color4ubv;
 344         snprintf(symboln, sizeof(symboln), "%sColor4ubv", symbol_prefix);
 345         *procp = dlsym(handle, symboln);
 346     }
 347
 348
 349     if(!disp->Color4ui) {
 350         void ** procp = (void **) &disp->Color4ui;
 351         snprintf(symboln, sizeof(symboln), "%sColor4ui", symbol_prefix);
 352         *procp = dlsym(handle, symboln);
 353     }
 354
 355
 356     if(!disp->Color4uiv) {
 357         void ** procp = (void **) &disp->Color4uiv;
 358         snprintf(symboln, sizeof(symboln), "%sColor4uiv", symbol_prefix);
 359         *procp = dlsym(handle, symboln);
 360     }
 361
 362
 363     if(!disp->Color4us) {
 364         void ** procp = (void **) &disp->Color4us;
 365         snprintf(symboln, sizeof(symboln), "%sColor4us", symbol_prefix);
 366         *procp = dlsym(handle, symboln);
 367     }
 368
 369
 370     if(!disp->Color4usv) {
 371         void ** procp = (void **) &disp->Color4usv;
 372         snprintf(symboln, sizeof(symboln), "%sColor4usv", symbol_prefix);
 373         *procp = dlsym(handle, symboln);
 374     }
 375
 376
 377     if(!disp->EdgeFlag) {
 378         void ** procp = (void **) &disp->EdgeFlag;
 379         snprintf(symboln, sizeof(symboln), "%sEdgeFlag", symbol_prefix);
 380         *procp = dlsym(handle, symboln);
 381     }
 382
 383
 384     if(!disp->EdgeFlagv) {
 385         void ** procp = (void **) &disp->EdgeFlagv;
 386         snprintf(symboln, sizeof(symboln), "%sEdgeFlagv", symbol_prefix);
 387         *procp = dlsym(handle, symboln);
 388     }
 389
 390
 391     if(!disp->End) {
 392         void ** procp = (void **) &disp->End;
 393         snprintf(symboln, sizeof(symboln), "%sEnd", symbol_prefix);
 394         *procp = dlsym(handle, symboln);
 395     }
 396
 397
 398     if(!disp->Indexd) {
 399         void ** procp = (void **) &disp->Indexd;
 400         snprintf(symboln, sizeof(symboln), "%sIndexd", symbol_prefix);
 401         *procp = dlsym(handle, symboln);
 402     }
 403
 404
 405     if(!disp->Indexdv) {
 406         void ** procp = (void **) &disp->Indexdv;
 407         snprintf(symboln, sizeof(symboln), "%sIndexdv", symbol_prefix);
 408         *procp = dlsym(handle, symboln);
 409     }
 410
 411
 412     if(!disp->Indexf) {
 413         void ** procp = (void **) &disp->Indexf;
 414         snprintf(symboln, sizeof(symboln), "%sIndexf", symbol_prefix);
 415         *procp = dlsym(handle, symboln);
 416     }
 417
 418
 419     if(!disp->Indexfv) {
 420         void ** procp = (void **) &disp->Indexfv;
 421         snprintf(symboln, sizeof(symboln), "%sIndexfv", symbol_prefix);
 422         *procp = dlsym(handle, symboln);
 423     }
 424
 425
 426     if(!disp->Indexi) {
 427         void ** procp = (void **) &disp->Indexi;
 428         snprintf(symboln, sizeof(symboln), "%sIndexi", symbol_prefix);
 429         *procp = dlsym(handle, symboln);
 430     }
 431
 432
 433     if(!disp->Indexiv) {
 434         void ** procp = (void **) &disp->Indexiv;
 435         snprintf(symboln, sizeof(symboln), "%sIndexiv", symbol_prefix);
 436         *procp = dlsym(handle, symboln);
 437     }
 438
 439
 440     if(!disp->Indexs) {
 441         void ** procp = (void **) &disp->Indexs;
 442         snprintf(symboln, sizeof(symboln), "%sIndexs", symbol_prefix);
 443         *procp = dlsym(handle, symboln);
 444     }
 445
 446
 447     if(!disp->Indexsv) {
 448         void ** procp = (void **) &disp->Indexsv;
 449         snprintf(symboln, sizeof(symboln), "%sIndexsv", symbol_prefix);
 450         *procp = dlsym(handle, symboln);
 451     }
 452
 453
 454     if(!disp->Normal3b) {
 455         void ** procp = (void **) &disp->Normal3b;
 456         snprintf(symboln, sizeof(symboln), "%sNormal3b", symbol_prefix);
 457         *procp = dlsym(handle, symboln);
 458     }
 459
 460
 461     if(!disp->Normal3bv) {
 462         void ** procp = (void **) &disp->Normal3bv;
 463         snprintf(symboln, sizeof(symboln), "%sNormal3bv", symbol_prefix);
 464         *procp = dlsym(handle, symboln);
 465     }
 466
 467
 468     if(!disp->Normal3d) {
 469         void ** procp = (void **) &disp->Normal3d;
 470         snprintf(symboln, sizeof(symboln), "%sNormal3d", symbol_prefix);
 471         *procp = dlsym(handle, symboln);
 472     }
 473
 474
 475     if(!disp->Normal3dv) {
 476         void ** procp = (void **) &disp->Normal3dv;
 477         snprintf(symboln, sizeof(symboln), "%sNormal3dv", symbol_prefix);
 478         *procp = dlsym(handle, symboln);
 479     }
 480
 481
 482     if(!disp->Normal3f) {
 483         void ** procp = (void **) &disp->Normal3f;
 484         snprintf(symboln, sizeof(symboln), "%sNormal3f", symbol_prefix);
 485         *procp = dlsym(handle, symboln);
 486     }
 487
 488
 489     if(!disp->Normal3fv) {
 490         void ** procp = (void **) &disp->Normal3fv;
 491         snprintf(symboln, sizeof(symboln), "%sNormal3fv", symbol_prefix);
 492         *procp = dlsym(handle, symboln);
 493     }
 494
 495
 496     if(!disp->Normal3i) {
 497         void ** procp = (void **) &disp->Normal3i;
 498         snprintf(symboln, sizeof(symboln), "%sNormal3i", symbol_prefix);
 499         *procp = dlsym(handle, symboln);
 500     }
 501
 502
 503     if(!disp->Normal3iv) {
 504         void ** procp = (void **) &disp->Normal3iv;
 505         snprintf(symboln, sizeof(symboln), "%sNormal3iv", symbol_prefix);
 506         *procp = dlsym(handle, symboln);
 507     }
 508
 509
 510     if(!disp->Normal3s) {
 511         void ** procp = (void **) &disp->Normal3s;
 512         snprintf(symboln, sizeof(symboln), "%sNormal3s", symbol_prefix);
 513         *procp = dlsym(handle, symboln);
 514     }
 515
 516
 517     if(!disp->Normal3sv) {
 518         void ** procp = (void **) &disp->Normal3sv;
 519         snprintf(symboln, sizeof(symboln), "%sNormal3sv", symbol_prefix);
 520         *procp = dlsym(handle, symboln);
 521     }
 522
 523
 524     if(!disp->RasterPos2d) {
 525         void ** procp = (void **) &disp->RasterPos2d;
 526         snprintf(symboln, sizeof(symboln), "%sRasterPos2d", symbol_prefix);
 527         *procp = dlsym(handle, symboln);
 528     }
 529
 530
 531     if(!disp->RasterPos2dv) {
 532         void ** procp = (void **) &disp->RasterPos2dv;
 533         snprintf(symboln, sizeof(symboln), "%sRasterPos2dv", symbol_prefix);
 534         *procp = dlsym(handle, symboln);
 535     }
 536
 537
 538     if(!disp->RasterPos2f) {
 539         void ** procp = (void **) &disp->RasterPos2f;
 540         snprintf(symboln, sizeof(symboln), "%sRasterPos2f", symbol_prefix);
 541         *procp = dlsym(handle, symboln);
 542     }
 543
 544
 545     if(!disp->RasterPos2fv) {
 546         void ** procp = (void **) &disp->RasterPos2fv;
 547         snprintf(symboln, sizeof(symboln), "%sRasterPos2fv", symbol_prefix);
 548         *procp = dlsym(handle, symboln);
 549     }
 550
 551
 552     if(!disp->RasterPos2i) {
 553         void ** procp = (void **) &disp->RasterPos2i;
 554         snprintf(symboln, sizeof(symboln), "%sRasterPos2i", symbol_prefix);
 555         *procp = dlsym(handle, symboln);
 556     }
 557
 558
 559     if(!disp->RasterPos2iv) {
 560         void ** procp = (void **) &disp->RasterPos2iv;
 561         snprintf(symboln, sizeof(symboln), "%sRasterPos2iv", symbol_prefix);
 562         *procp = dlsym(handle, symboln);
 563     }
 564
 565
 566     if(!disp->RasterPos2s) {
 567         void ** procp = (void **) &disp->RasterPos2s;
 568         snprintf(symboln, sizeof(symboln), "%sRasterPos2s", symbol_prefix);
 569         *procp = dlsym(handle, symboln);
 570     }
 571
 572
 573     if(!disp->RasterPos2sv) {
 574         void ** procp = (void **) &disp->RasterPos2sv;
 575         snprintf(symboln, sizeof(symboln), "%sRasterPos2sv", symbol_prefix);
 576         *procp = dlsym(handle, symboln);
 577     }
 578
 579
 580     if(!disp->RasterPos3d) {
 581         void ** procp = (void **) &disp->RasterPos3d;
 582         snprintf(symboln, sizeof(symboln), "%sRasterPos3d", symbol_prefix);
 583         *procp = dlsym(handle, symboln);
 584     }
 585
 586
 587     if(!disp->RasterPos3dv) {
 588         void ** procp = (void **) &disp->RasterPos3dv;
 589         snprintf(symboln, sizeof(symboln), "%sRasterPos3dv", symbol_prefix);
 590         *procp = dlsym(handle, symboln);
 591     }
 592
 593
 594     if(!disp->RasterPos3f) {
 595         void ** procp = (void **) &disp->RasterPos3f;
 596         snprintf(symboln, sizeof(symboln), "%sRasterPos3f", symbol_prefix);
 597         *procp = dlsym(handle, symboln);
 598     }
 599
 600
 601     if(!disp->RasterPos3fv) {
 602         void ** procp = (void **) &disp->RasterPos3fv;
 603         snprintf(symboln, sizeof(symboln), "%sRasterPos3fv", symbol_prefix);
 604         *procp = dlsym(handle, symboln);
 605     }
 606
 607
 608     if(!disp->RasterPos3i) {
 609         void ** procp = (void **) &disp->RasterPos3i;
 610         snprintf(symboln, sizeof(symboln), "%sRasterPos3i", symbol_prefix);
 611         *procp = dlsym(handle, symboln);
 612     }
 613
 614
 615     if(!disp->RasterPos3iv) {
 616         void ** procp = (void **) &disp->RasterPos3iv;
 617         snprintf(symboln, sizeof(symboln), "%sRasterPos3iv", symbol_prefix);
 618         *procp = dlsym(handle, symboln);
 619     }
 620
 621
 622     if(!disp->RasterPos3s) {
 623         void ** procp = (void **) &disp->RasterPos3s;
 624         snprintf(symboln, sizeof(symboln), "%sRasterPos3s", symbol_prefix);
 625         *procp = dlsym(handle, symboln);
 626     }
 627
 628
 629     if(!disp->RasterPos3sv) {
 630         void ** procp = (void **) &disp->RasterPos3sv;
 631         snprintf(symboln, sizeof(symboln), "%sRasterPos3sv", symbol_prefix);
 632         *procp = dlsym(handle, symboln);
 633     }
 634
 635
 636     if(!disp->RasterPos4d) {
 637         void ** procp = (void **) &disp->RasterPos4d;
 638         snprintf(symboln, sizeof(symboln), "%sRasterPos4d", symbol_prefix);
 639         *procp = dlsym(handle, symboln);
 640     }
 641
 642
 643     if(!disp->RasterPos4dv) {
 644         void ** procp = (void **) &disp->RasterPos4dv;
 645         snprintf(symboln, sizeof(symboln), "%sRasterPos4dv", symbol_prefix);
 646         *procp = dlsym(handle, symboln);
 647     }
 648
 649
 650     if(!disp->RasterPos4f) {
 651         void ** procp = (void **) &disp->RasterPos4f;
 652         snprintf(symboln, sizeof(symboln), "%sRasterPos4f", symbol_prefix);
 653         *procp = dlsym(handle, symboln);
 654     }
 655
 656
 657     if(!disp->RasterPos4fv) {
 658         void ** procp = (void **) &disp->RasterPos4fv;
 659         snprintf(symboln, sizeof(symboln), "%sRasterPos4fv", symbol_prefix);
 660         *procp = dlsym(handle, symboln);
 661     }
 662
 663
 664     if(!disp->RasterPos4i) {
 665         void ** procp = (void **) &disp->RasterPos4i;
 666         snprintf(symboln, sizeof(symboln), "%sRasterPos4i", symbol_prefix);
 667         *procp = dlsym(handle, symboln);
 668     }
 669
 670
 671     if(!disp->RasterPos4iv) {
 672         void ** procp = (void **) &disp->RasterPos4iv;
 673         snprintf(symboln, sizeof(symboln), "%sRasterPos4iv", symbol_prefix);
 674         *procp = dlsym(handle, symboln);
 675     }
 676
 677
 678     if(!disp->RasterPos4s) {
 679         void ** procp = (void **) &disp->RasterPos4s;
 680         snprintf(symboln, sizeof(symboln), "%sRasterPos4s", symbol_prefix);
 681         *procp = dlsym(handle, symboln);
 682     }
 683
 684
 685     if(!disp->RasterPos4sv) {
 686         void ** procp = (void **) &disp->RasterPos4sv;
 687         snprintf(symboln, sizeof(symboln), "%sRasterPos4sv", symbol_prefix);
 688         *procp = dlsym(handle, symboln);
 689     }
 690
 691
 692     if(!disp->Rectd) {
 693         void ** procp = (void **) &disp->Rectd;
 694         snprintf(symboln, sizeof(symboln), "%sRectd", symbol_prefix);
 695         *procp = dlsym(handle, symboln);
 696     }
 697
 698
 699     if(!disp->Rectdv) {
 700         void ** procp = (void **) &disp->Rectdv;
 701         snprintf(symboln, sizeof(symboln), "%sRectdv", symbol_prefix);
 702         *procp = dlsym(handle, symboln);
 703     }
 704
 705
 706     if(!disp->Rectf) {
 707         void ** procp = (void **) &disp->Rectf;
 708         snprintf(symboln, sizeof(symboln), "%sRectf", symbol_prefix);
 709         *procp = dlsym(handle, symboln);
 710     }
 711
 712
 713     if(!disp->Rectfv) {
 714         void ** procp = (void **) &disp->Rectfv;
 715         snprintf(symboln, sizeof(symboln), "%sRectfv", symbol_prefix);
 716         *procp = dlsym(handle, symboln);
 717     }
 718
 719
 720     if(!disp->Recti) {
 721         void ** procp = (void **) &disp->Recti;
 722         snprintf(symboln, sizeof(symboln), "%sRecti", symbol_prefix);
 723         *procp = dlsym(handle, symboln);
 724     }
 725
 726
 727     if(!disp->Rectiv) {
 728         void ** procp = (void **) &disp->Rectiv;
 729         snprintf(symboln, sizeof(symboln), "%sRectiv", symbol_prefix);
 730         *procp = dlsym(handle, symboln);
 731     }
 732
 733
 734     if(!disp->Rects) {
 735         void ** procp = (void **) &disp->Rects;
 736         snprintf(symboln, sizeof(symboln), "%sRects", symbol_prefix);
 737         *procp = dlsym(handle, symboln);
 738     }
 739
 740
 741     if(!disp->Rectsv) {
 742         void ** procp = (void **) &disp->Rectsv;
 743         snprintf(symboln, sizeof(symboln), "%sRectsv", symbol_prefix);
 744         *procp = dlsym(handle, symboln);
 745     }
 746
 747
 748     if(!disp->TexCoord1d) {
 749         void ** procp = (void **) &disp->TexCoord1d;
 750         snprintf(symboln, sizeof(symboln), "%sTexCoord1d", symbol_prefix);
 751         *procp = dlsym(handle, symboln);
 752     }
 753
 754
 755     if(!disp->TexCoord1dv) {
 756         void ** procp = (void **) &disp->TexCoord1dv;
 757         snprintf(symboln, sizeof(symboln), "%sTexCoord1dv", symbol_prefix);
 758         *procp = dlsym(handle, symboln);
 759     }
 760
 761
 762     if(!disp->TexCoord1f) {
 763         void ** procp = (void **) &disp->TexCoord1f;
 764         snprintf(symboln, sizeof(symboln), "%sTexCoord1f", symbol_prefix);
 765         *procp = dlsym(handle, symboln);
 766     }
 767
 768
 769     if(!disp->TexCoord1fv) {
 770         void ** procp = (void **) &disp->TexCoord1fv;
 771         snprintf(symboln, sizeof(symboln), "%sTexCoord1fv", symbol_prefix);
 772         *procp = dlsym(handle, symboln);
 773     }
 774
 775
 776     if(!disp->TexCoord1i) {
 777         void ** procp = (void **) &disp->TexCoord1i;
 778         snprintf(symboln, sizeof(symboln), "%sTexCoord1i", symbol_prefix);
 779         *procp = dlsym(handle, symboln);
 780     }
 781
 782
 783     if(!disp->TexCoord1iv) {
 784         void ** procp = (void **) &disp->TexCoord1iv;
 785         snprintf(symboln, sizeof(symboln), "%sTexCoord1iv", symbol_prefix);
 786         *procp = dlsym(handle, symboln);
 787     }
 788
 789
 790     if(!disp->TexCoord1s) {
 791         void ** procp = (void **) &disp->TexCoord1s;
 792         snprintf(symboln, sizeof(symboln), "%sTexCoord1s", symbol_prefix);
 793         *procp = dlsym(handle, symboln);
 794     }
 795
 796
 797     if(!disp->TexCoord1sv) {
 798         void ** procp = (void **) &disp->TexCoord1sv;
 799         snprintf(symboln, sizeof(symboln), "%sTexCoord1sv", symbol_prefix);
 800         *procp = dlsym(handle, symboln);
 801     }
 802
 803
 804     if(!disp->TexCoord2d) {
 805         void ** procp = (void **) &disp->TexCoord2d;
 806         snprintf(symboln, sizeof(symboln), "%sTexCoord2d", symbol_prefix);
 807         *procp = dlsym(handle, symboln);
 808     }
 809
 810
 811     if(!disp->TexCoord2dv) {
 812         void ** procp = (void **) &disp->TexCoord2dv;
 813         snprintf(symboln, sizeof(symboln), "%sTexCoord2dv", symbol_prefix);
 814         *procp = dlsym(handle, symboln);
 815     }
 816
 817
 818     if(!disp->TexCoord2f) {
 819         void ** procp = (void **) &disp->TexCoord2f;
 820         snprintf(symboln, sizeof(symboln), "%sTexCoord2f", symbol_prefix);
 821         *procp = dlsym(handle, symboln);
 822     }
 823
 824
 825     if(!disp->TexCoord2fv) {
 826         void ** procp = (void **) &disp->TexCoord2fv;
 827         snprintf(symboln, sizeof(symboln), "%sTexCoord2fv", symbol_prefix);
 828         *procp = dlsym(handle, symboln);
 829     }
 830
 831
 832     if(!disp->TexCoord2i) {
 833         void ** procp = (void **) &disp->TexCoord2i;
 834         snprintf(symboln, sizeof(symboln), "%sTexCoord2i", symbol_prefix);
 835         *procp = dlsym(handle, symboln);
 836     }
 837
 838
 839     if(!disp->TexCoord2iv) {
 840         void ** procp = (void **) &disp->TexCoord2iv;
 841         snprintf(symboln, sizeof(symboln), "%sTexCoord2iv", symbol_prefix);
 842         *procp = dlsym(handle, symboln);
 843     }
 844
 845
 846     if(!disp->TexCoord2s) {
 847         void ** procp = (void **) &disp->TexCoord2s;
 848         snprintf(symboln, sizeof(symboln), "%sTexCoord2s", symbol_prefix);
 849         *procp = dlsym(handle, symboln);
 850     }
 851
 852
 853     if(!disp->TexCoord2sv) {
 854         void ** procp = (void **) &disp->TexCoord2sv;
 855         snprintf(symboln, sizeof(symboln), "%sTexCoord2sv", symbol_prefix);
 856         *procp = dlsym(handle, symboln);
 857     }
 858
 859
 860     if(!disp->TexCoord3d) {
 861         void ** procp = (void **) &disp->TexCoord3d;
 862         snprintf(symboln, sizeof(symboln), "%sTexCoord3d", symbol_prefix);
 863         *procp = dlsym(handle, symboln);
 864     }
 865
 866
 867     if(!disp->TexCoord3dv) {
 868         void ** procp = (void **) &disp->TexCoord3dv;
 869         snprintf(symboln, sizeof(symboln), "%sTexCoord3dv", symbol_prefix);
 870         *procp = dlsym(handle, symboln);
 871     }
 872
 873
 874     if(!disp->TexCoord3f) {
 875         void ** procp = (void **) &disp->TexCoord3f;
 876         snprintf(symboln, sizeof(symboln), "%sTexCoord3f", symbol_prefix);
 877         *procp = dlsym(handle, symboln);
 878     }
 879
 880
 881     if(!disp->TexCoord3fv) {
 882         void ** procp = (void **) &disp->TexCoord3fv;
 883         snprintf(symboln, sizeof(symboln), "%sTexCoord3fv", symbol_prefix);
 884         *procp = dlsym(handle, symboln);
 885     }
 886
 887
 888     if(!disp->TexCoord3i) {
 889         void ** procp = (void **) &disp->TexCoord3i;
 890         snprintf(symboln, sizeof(symboln), "%sTexCoord3i", symbol_prefix);
 891         *procp = dlsym(handle, symboln);
 892     }
 893
 894
 895     if(!disp->TexCoord3iv) {
 896         void ** procp = (void **) &disp->TexCoord3iv;
 897         snprintf(symboln, sizeof(symboln), "%sTexCoord3iv", symbol_prefix);
 898         *procp = dlsym(handle, symboln);
 899     }
 900
 901
 902     if(!disp->TexCoord3s) {
 903         void ** procp = (void **) &disp->TexCoord3s;
 904         snprintf(symboln, sizeof(symboln), "%sTexCoord3s", symbol_prefix);
 905         *procp = dlsym(handle, symboln);
 906     }
 907
 908
 909     if(!disp->TexCoord3sv) {
 910         void ** procp = (void **) &disp->TexCoord3sv;
 911         snprintf(symboln, sizeof(symboln), "%sTexCoord3sv", symbol_prefix);
 912         *procp = dlsym(handle, symboln);
 913     }
 914
 915
 916     if(!disp->TexCoord4d) {
 917         void ** procp = (void **) &disp->TexCoord4d;
 918         snprintf(symboln, sizeof(symboln), "%sTexCoord4d", symbol_prefix);
 919         *procp = dlsym(handle, symboln);
 920     }
 921
 922
 923     if(!disp->TexCoord4dv) {
 924         void ** procp = (void **) &disp->TexCoord4dv;
 925         snprintf(symboln, sizeof(symboln), "%sTexCoord4dv", symbol_prefix);
 926         *procp = dlsym(handle, symboln);
 927     }
 928
 929
 930     if(!disp->TexCoord4f) {
 931         void ** procp = (void **) &disp->TexCoord4f;
 932         snprintf(symboln, sizeof(symboln), "%sTexCoord4f", symbol_prefix);
 933         *procp = dlsym(handle, symboln);
 934     }
 935
 936
 937     if(!disp->TexCoord4fv) {
 938         void ** procp = (void **) &disp->TexCoord4fv;
 939         snprintf(symboln, sizeof(symboln), "%sTexCoord4fv", symbol_prefix);
 940         *procp = dlsym(handle, symboln);
 941     }
 942
 943
 944     if(!disp->TexCoord4i) {
 945         void ** procp = (void **) &disp->TexCoord4i;
 946         snprintf(symboln, sizeof(symboln), "%sTexCoord4i", symbol_prefix);
 947         *procp = dlsym(handle, symboln);
 948     }
 949
 950
 951     if(!disp->TexCoord4iv) {
 952         void ** procp = (void **) &disp->TexCoord4iv;
 953         snprintf(symboln, sizeof(symboln), "%sTexCoord4iv", symbol_prefix);
 954         *procp = dlsym(handle, symboln);
 955     }
 956
 957
 958     if(!disp->TexCoord4s) {
 959         void ** procp = (void **) &disp->TexCoord4s;
 960         snprintf(symboln, sizeof(symboln), "%sTexCoord4s", symbol_prefix);
 961         *procp = dlsym(handle, symboln);
 962     }
 963
 964
 965     if(!disp->TexCoord4sv) {
 966         void ** procp = (void **) &disp->TexCoord4sv;
 967         snprintf(symboln, sizeof(symboln), "%sTexCoord4sv", symbol_prefix);
 968         *procp = dlsym(handle, symboln);
 969     }
 970
 971
 972     if(!disp->Vertex2d) {
 973         void ** procp = (void **) &disp->Vertex2d;
 974         snprintf(symboln, sizeof(symboln), "%sVertex2d", symbol_prefix);
 975         *procp = dlsym(handle, symboln);
 976     }
 977
 978
 979     if(!disp->Vertex2dv) {
 980         void ** procp = (void **) &disp->Vertex2dv;
 981         snprintf(symboln, sizeof(symboln), "%sVertex2dv", symbol_prefix);
 982         *procp = dlsym(handle, symboln);
 983     }
 984
 985
 986     if(!disp->Vertex2f) {
 987         void ** procp = (void **) &disp->Vertex2f;
 988         snprintf(symboln, sizeof(symboln), "%sVertex2f", symbol_prefix);
 989         *procp = dlsym(handle, symboln);
 990     }
 991
 992
 993     if(!disp->Vertex2fv) {
 994         void ** procp = (void **) &disp->Vertex2fv;
 995         snprintf(symboln, sizeof(symboln), "%sVertex2fv", symbol_prefix);
 996         *procp = dlsym(handle, symboln);
 997     }
 998
 999
1000     if(!disp->Vertex2i) {
1001         void ** procp = (void **) &disp->Vertex2i;
1002         snprintf(symboln, sizeof(symboln), "%sVertex2i", symbol_prefix);
1003         *procp = dlsym(handle, symboln);
1004     }
1005
1006
1007     if(!disp->Vertex2iv) {
1008         void ** procp = (void **) &disp->Vertex2iv;
1009         snprintf(symboln, sizeof(symboln), "%sVertex2iv", symbol_prefix);
1010         *procp = dlsym(handle, symboln);
1011     }
1012
1013
1014     if(!disp->Vertex2s) {
1015         void ** procp = (void **) &disp->Vertex2s;
1016         snprintf(symboln, sizeof(symboln), "%sVertex2s", symbol_prefix);
1017         *procp = dlsym(handle, symboln);
1018     }
1019
1020
1021     if(!disp->Vertex2sv) {
1022         void ** procp = (void **) &disp->Vertex2sv;
1023         snprintf(symboln, sizeof(symboln), "%sVertex2sv", symbol_prefix);
1024         *procp = dlsym(handle, symboln);
1025     }
1026
1027
1028     if(!disp->Vertex3d) {
1029         void ** procp = (void **) &disp->Vertex3d;
1030         snprintf(symboln, sizeof(symboln), "%sVertex3d", symbol_prefix);
1031         *procp = dlsym(handle, symboln);
1032     }
1033
1034
1035     if(!disp->Vertex3dv) {
1036         void ** procp = (void **) &disp->Vertex3dv;
1037         snprintf(symboln, sizeof(symboln), "%sVertex3dv", symbol_prefix);
1038         *procp = dlsym(handle, symboln);
1039     }
1040
1041
1042     if(!disp->Vertex3f) {
1043         void ** procp = (void **) &disp->Vertex3f;
1044         snprintf(symboln, sizeof(symboln), "%sVertex3f", symbol_prefix);
1045         *procp = dlsym(handle, symboln);
1046     }
1047
1048
1049     if(!disp->Vertex3fv) {
1050         void ** procp = (void **) &disp->Vertex3fv;
1051         snprintf(symboln, sizeof(symboln), "%sVertex3fv", symbol_prefix);
1052         *procp = dlsym(handle, symboln);
1053     }
1054
1055
1056     if(!disp->Vertex3i) {
1057         void ** procp = (void **) &disp->Vertex3i;
1058         snprintf(symboln, sizeof(symboln), "%sVertex3i", symbol_prefix);
1059         *procp = dlsym(handle, symboln);
1060     }
1061
1062
1063     if(!disp->Vertex3iv) {
1064         void ** procp = (void **) &disp->Vertex3iv;
1065         snprintf(symboln, sizeof(symboln), "%sVertex3iv", symbol_prefix);
1066         *procp = dlsym(handle, symboln);
1067     }
1068
1069
1070     if(!disp->Vertex3s) {
1071         void ** procp = (void **) &disp->Vertex3s;
1072         snprintf(symboln, sizeof(symboln), "%sVertex3s", symbol_prefix);
1073         *procp = dlsym(handle, symboln);
1074     }
1075
1076
1077     if(!disp->Vertex3sv) {
1078         void ** procp = (void **) &disp->Vertex3sv;
1079         snprintf(symboln, sizeof(symboln), "%sVertex3sv", symbol_prefix);
1080         *procp = dlsym(handle, symboln);
1081     }
1082
1083
1084     if(!disp->Vertex4d) {
1085         void ** procp = (void **) &disp->Vertex4d;
1086         snprintf(symboln, sizeof(symboln), "%sVertex4d", symbol_prefix);
1087         *procp = dlsym(handle, symboln);
1088     }
1089
1090
1091     if(!disp->Vertex4dv) {
1092         void ** procp = (void **) &disp->Vertex4dv;
1093         snprintf(symboln, sizeof(symboln), "%sVertex4dv", symbol_prefix);
1094         *procp = dlsym(handle, symboln);
1095     }
1096
1097
1098     if(!disp->Vertex4f) {
1099         void ** procp = (void **) &disp->Vertex4f;
1100         snprintf(symboln, sizeof(symboln), "%sVertex4f", symbol_prefix);
1101         *procp = dlsym(handle, symboln);
1102     }
1103
1104
1105     if(!disp->Vertex4fv) {
1106         void ** procp = (void **) &disp->Vertex4fv;
1107         snprintf(symboln, sizeof(symboln), "%sVertex4fv", symbol_prefix);
1108         *procp = dlsym(handle, symboln);
1109     }
1110
1111
1112     if(!disp->Vertex4i) {
1113         void ** procp = (void **) &disp->Vertex4i;
1114         snprintf(symboln, sizeof(symboln), "%sVertex4i", symbol_prefix);
1115         *procp = dlsym(handle, symboln);
1116     }
1117
1118
1119     if(!disp->Vertex4iv) {
1120         void ** procp = (void **) &disp->Vertex4iv;
1121         snprintf(symboln, sizeof(symboln), "%sVertex4iv", symbol_prefix);
1122         *procp = dlsym(handle, symboln);
1123     }
1124
1125
1126     if(!disp->Vertex4s) {
1127         void ** procp = (void **) &disp->Vertex4s;
1128         snprintf(symboln, sizeof(symboln), "%sVertex4s", symbol_prefix);
1129         *procp = dlsym(handle, symboln);
1130     }
1131
1132
1133     if(!disp->Vertex4sv) {
1134         void ** procp = (void **) &disp->Vertex4sv;
1135         snprintf(symboln, sizeof(symboln), "%sVertex4sv", symbol_prefix);
1136         *procp = dlsym(handle, symboln);
1137     }
1138
1139
1140     if(!disp->ClipPlane) {
1141         void ** procp = (void **) &disp->ClipPlane;
1142         snprintf(symboln, sizeof(symboln), "%sClipPlane", symbol_prefix);
1143         *procp = dlsym(handle, symboln);
1144     }
1145
1146
1147     if(!disp->ColorMaterial) {
1148         void ** procp = (void **) &disp->ColorMaterial;
1149         snprintf(symboln, sizeof(symboln), "%sColorMaterial", symbol_prefix);
1150         *procp = dlsym(handle, symboln);
1151     }
1152
1153
1154     if(!disp->CullFace) {
1155         void ** procp = (void **) &disp->CullFace;
1156         snprintf(symboln, sizeof(symboln), "%sCullFace", symbol_prefix);
1157         *procp = dlsym(handle, symboln);
1158     }
1159
1160
1161     if(!disp->Fogf) {
1162         void ** procp = (void **) &disp->Fogf;
1163         snprintf(symboln, sizeof(symboln), "%sFogf", symbol_prefix);
1164         *procp = dlsym(handle, symboln);
1165     }
1166
1167
1168     if(!disp->Fogfv) {
1169         void ** procp = (void **) &disp->Fogfv;
1170         snprintf(symboln, sizeof(symboln), "%sFogfv", symbol_prefix);
1171         *procp = dlsym(handle, symboln);
1172     }
1173
1174
1175     if(!disp->Fogi) {
1176         void ** procp = (void **) &disp->Fogi;
1177         snprintf(symboln, sizeof(symboln), "%sFogi", symbol_prefix);
1178         *procp = dlsym(handle, symboln);
1179     }
1180
1181
1182     if(!disp->Fogiv) {
1183         void ** procp = (void **) &disp->Fogiv;
1184         snprintf(symboln, sizeof(symboln), "%sFogiv", symbol_prefix);
1185         *procp = dlsym(handle, symboln);
1186     }
1187
1188
1189     if(!disp->FrontFace) {
1190         void ** procp = (void **) &disp->FrontFace;
1191         snprintf(symboln, sizeof(symboln), "%sFrontFace", symbol_prefix);
1192         *procp = dlsym(handle, symboln);
1193     }
1194
1195
1196     if(!disp->Hint) {
1197         void ** procp = (void **) &disp->Hint;
1198         snprintf(symboln, sizeof(symboln), "%sHint", symbol_prefix);
1199         *procp = dlsym(handle, symboln);
1200     }
1201
1202
1203     if(!disp->Lightf) {
1204         void ** procp = (void **) &disp->Lightf;
1205         snprintf(symboln, sizeof(symboln), "%sLightf", symbol_prefix);
1206         *procp = dlsym(handle, symboln);
1207     }
1208
1209
1210     if(!disp->Lightfv) {
1211         void ** procp = (void **) &disp->Lightfv;
1212         snprintf(symboln, sizeof(symboln), "%sLightfv", symbol_prefix);
1213         *procp = dlsym(handle, symboln);
1214     }
1215
1216
1217     if(!disp->Lighti) {
1218         void ** procp = (void **) &disp->Lighti;
1219         snprintf(symboln, sizeof(symboln), "%sLighti", symbol_prefix);
1220         *procp = dlsym(handle, symboln);
1221     }
1222
1223
1224     if(!disp->Lightiv) {
1225         void ** procp = (void **) &disp->Lightiv;
1226         snprintf(symboln, sizeof(symboln), "%sLightiv", symbol_prefix);
1227         *procp = dlsym(handle, symboln);
1228     }
1229
1230
1231     if(!disp->LightModelf) {
1232         void ** procp = (void **) &disp->LightModelf;
1233         snprintf(symboln, sizeof(symboln), "%sLightModelf", symbol_prefix);
1234         *procp = dlsym(handle, symboln);
1235     }
1236
1237
1238     if(!disp->LightModelfv) {
1239         void ** procp = (void **) &disp->LightModelfv;
1240         snprintf(symboln, sizeof(symboln), "%sLightModelfv", symbol_prefix);
1241         *procp = dlsym(handle, symboln);
1242     }
1243
1244
1245     if(!disp->LightModeli) {
1246         void ** procp = (void **) &disp->LightModeli;
1247         snprintf(symboln, sizeof(symboln), "%sLightModeli", symbol_prefix);
1248         *procp = dlsym(handle, symboln);
1249     }
1250
1251
1252     if(!disp->LightModeliv) {
1253         void ** procp = (void **) &disp->LightModeliv;
1254         snprintf(symboln, sizeof(symboln), "%sLightModeliv", symbol_prefix);
1255         *procp = dlsym(handle, symboln);
1256     }
1257
1258
1259     if(!disp->LineStipple) {
1260         void ** procp = (void **) &disp->LineStipple;
1261         snprintf(symboln, sizeof(symboln), "%sLineStipple", symbol_prefix);
1262         *procp = dlsym(handle, symboln);
1263     }
1264
1265
1266     if(!disp->LineWidth) {
1267         void ** procp = (void **) &disp->LineWidth;
1268         snprintf(symboln, sizeof(symboln), "%sLineWidth", symbol_prefix);
1269         *procp = dlsym(handle, symboln);
1270     }
1271
1272
1273     if(!disp->Materialf) {
1274         void ** procp = (void **) &disp->Materialf;
1275         snprintf(symboln, sizeof(symboln), "%sMaterialf", symbol_prefix);
1276         *procp = dlsym(handle, symboln);
1277     }
1278
1279
1280     if(!disp->Materialfv) {
1281         void ** procp = (void **) &disp->Materialfv;
1282         snprintf(symboln, sizeof(symboln), "%sMaterialfv", symbol_prefix);
1283         *procp = dlsym(handle, symboln);
1284     }
1285
1286
1287     if(!disp->Materiali) {
1288         void ** procp = (void **) &disp->Materiali;
1289         snprintf(symboln, sizeof(symboln), "%sMateriali", symbol_prefix);
1290         *procp = dlsym(handle, symboln);
1291     }
1292
1293
1294     if(!disp->Materialiv) {
1295         void ** procp = (void **) &disp->Materialiv;
1296         snprintf(symboln, sizeof(symboln), "%sMaterialiv", symbol_prefix);
1297         *procp = dlsym(handle, symboln);
1298     }
1299
1300
1301     if(!disp->PointSize) {
1302         void ** procp = (void **) &disp->PointSize;
1303         snprintf(symboln, sizeof(symboln), "%sPointSize", symbol_prefix);
1304         *procp = dlsym(handle, symboln);
1305     }
1306
1307
1308     if(!disp->PolygonMode) {
1309         void ** procp = (void **) &disp->PolygonMode;
1310         snprintf(symboln, sizeof(symboln), "%sPolygonMode", symbol_prefix);
1311         *procp = dlsym(handle, symboln);
1312     }
1313
1314
1315     if(!disp->PolygonStipple) {
1316         void ** procp = (void **) &disp->PolygonStipple;
1317         snprintf(symboln, sizeof(symboln), "%sPolygonStipple", symbol_prefix);
1318         *procp = dlsym(handle, symboln);
1319     }
1320
1321
1322     if(!disp->Scissor) {
1323         void ** procp = (void **) &disp->Scissor;
1324         snprintf(symboln, sizeof(symboln), "%sScissor", symbol_prefix);
1325         *procp = dlsym(handle, symboln);
1326     }
1327
1328
1329     if(!disp->ShadeModel) {
1330         void ** procp = (void **) &disp->ShadeModel;
1331         snprintf(symboln, sizeof(symboln), "%sShadeModel", symbol_prefix);
1332         *procp = dlsym(handle, symboln);
1333     }
1334
1335
1336     if(!disp->TexParameterf) {
1337         void ** procp = (void **) &disp->TexParameterf;
1338         snprintf(symboln, sizeof(symboln), "%sTexParameterf", symbol_prefix);
1339         *procp = dlsym(handle, symboln);
1340     }
1341
1342
1343     if(!disp->TexParameterfv) {
1344         void ** procp = (void **) &disp->TexParameterfv;
1345         snprintf(symboln, sizeof(symboln), "%sTexParameterfv", symbol_prefix);
1346         *procp = dlsym(handle, symboln);
1347     }
1348
1349
1350     if(!disp->TexParameteri) {
1351         void ** procp = (void **) &disp->TexParameteri;
1352         snprintf(symboln, sizeof(symboln), "%sTexParameteri", symbol_prefix);
1353         *procp = dlsym(handle, symboln);
1354     }
1355
1356
1357     if(!disp->TexParameteriv) {
1358         void ** procp = (void **) &disp->TexParameteriv;
1359         snprintf(symboln, sizeof(symboln), "%sTexParameteriv", symbol_prefix);
1360         *procp = dlsym(handle, symboln);
1361     }
1362
1363
1364     if(!disp->TexImage1D) {
1365         void ** procp = (void **) &disp->TexImage1D;
1366         snprintf(symboln, sizeof(symboln), "%sTexImage1D", symbol_prefix);
1367         *procp = dlsym(handle, symboln);
1368     }
1369
1370
1371     if(!disp->TexImage2D) {
1372         void ** procp = (void **) &disp->TexImage2D;
1373         snprintf(symboln, sizeof(symboln), "%sTexImage2D", symbol_prefix);
1374         *procp = dlsym(handle, symboln);
1375     }
1376
1377
1378     if(!disp->TexEnvf) {
1379         void ** procp = (void **) &disp->TexEnvf;
1380         snprintf(symboln, sizeof(symboln), "%sTexEnvf", symbol_prefix);
1381         *procp = dlsym(handle, symboln);
1382     }
1383
1384
1385     if(!disp->TexEnvfv) {
1386         void ** procp = (void **) &disp->TexEnvfv;
1387         snprintf(symboln, sizeof(symboln), "%sTexEnvfv", symbol_prefix);
1388         *procp = dlsym(handle, symboln);
1389     }
1390
1391
1392     if(!disp->TexEnvi) {
1393         void ** procp = (void **) &disp->TexEnvi;
1394         snprintf(symboln, sizeof(symboln), "%sTexEnvi", symbol_prefix);
1395         *procp = dlsym(handle, symboln);
1396     }
1397
1398
1399     if(!disp->TexEnviv) {
1400         void ** procp = (void **) &disp->TexEnviv;
1401         snprintf(symboln, sizeof(symboln), "%sTexEnviv", symbol_prefix);
1402         *procp = dlsym(handle, symboln);
1403     }
1404
1405
1406     if(!disp->TexGend) {
1407         void ** procp = (void **) &disp->TexGend;
1408         snprintf(symboln, sizeof(symboln), "%sTexGend", symbol_prefix);
1409         *procp = dlsym(handle, symboln);
1410     }
1411
1412
1413     if(!disp->TexGendv) {
1414         void ** procp = (void **) &disp->TexGendv;
1415         snprintf(symboln, sizeof(symboln), "%sTexGendv", symbol_prefix);
1416         *procp = dlsym(handle, symboln);
1417     }
1418
1419
1420     if(!disp->TexGenf) {
1421         void ** procp = (void **) &disp->TexGenf;
1422         snprintf(symboln, sizeof(symboln), "%sTexGenf", symbol_prefix);
1423         *procp = dlsym(handle, symboln);
1424     }
1425
1426
1427     if(!disp->TexGenfv) {
1428         void ** procp = (void **) &disp->TexGenfv;
1429         snprintf(symboln, sizeof(symboln), "%sTexGenfv", symbol_prefix);
1430         *procp = dlsym(handle, symboln);
1431     }
1432
1433
1434     if(!disp->TexGeni) {
1435         void ** procp = (void **) &disp->TexGeni;
1436         snprintf(symboln, sizeof(symboln), "%sTexGeni", symbol_prefix);
1437         *procp = dlsym(handle, symboln);
1438     }
1439
1440
1441     if(!disp->TexGeniv) {
1442         void ** procp = (void **) &disp->TexGeniv;
1443         snprintf(symboln, sizeof(symboln), "%sTexGeniv", symbol_prefix);
1444         *procp = dlsym(handle, symboln);
1445     }
1446
1447
1448     if(!disp->FeedbackBuffer) {
1449         void ** procp = (void **) &disp->FeedbackBuffer;
1450         snprintf(symboln, sizeof(symboln), "%sFeedbackBuffer", symbol_prefix);
1451         *procp = dlsym(handle, symboln);
1452     }
1453
1454
1455     if(!disp->SelectBuffer) {
1456         void ** procp = (void **) &disp->SelectBuffer;
1457         snprintf(symboln, sizeof(symboln), "%sSelectBuffer", symbol_prefix);
1458         *procp = dlsym(handle, symboln);
1459     }
1460
1461
1462     if(!disp->RenderMode) {
1463         void ** procp = (void **) &disp->RenderMode;
1464         snprintf(symboln, sizeof(symboln), "%sRenderMode", symbol_prefix);
1465         *procp = dlsym(handle, symboln);
1466     }
1467
1468
1469     if(!disp->InitNames) {
1470         void ** procp = (void **) &disp->InitNames;
1471         snprintf(symboln, sizeof(symboln), "%sInitNames", symbol_prefix);
1472         *procp = dlsym(handle, symboln);
1473     }
1474
1475
1476     if(!disp->LoadName) {
1477         void ** procp = (void **) &disp->LoadName;
1478         snprintf(symboln, sizeof(symboln), "%sLoadName", symbol_prefix);
1479         *procp = dlsym(handle, symboln);
1480     }
1481
1482
1483     if(!disp->PassThrough) {
1484         void ** procp = (void **) &disp->PassThrough;
1485         snprintf(symboln, sizeof(symboln), "%sPassThrough", symbol_prefix);
1486         *procp = dlsym(handle, symboln);
1487     }
1488
1489
1490     if(!disp->PopName) {
1491         void ** procp = (void **) &disp->PopName;
1492         snprintf(symboln, sizeof(symboln), "%sPopName", symbol_prefix);
1493         *procp = dlsym(handle, symboln);
1494     }
1495
1496
1497     if(!disp->PushName) {
1498         void ** procp = (void **) &disp->PushName;
1499         snprintf(symboln, sizeof(symboln), "%sPushName", symbol_prefix);
1500         *procp = dlsym(handle, symboln);
1501     }
1502
1503
1504     if(!disp->DrawBuffer) {
1505         void ** procp = (void **) &disp->DrawBuffer;
1506         snprintf(symboln, sizeof(symboln), "%sDrawBuffer", symbol_prefix);
1507         *procp = dlsym(handle, symboln);
1508     }
1509
1510
1511     if(!disp->Clear) {
1512         void ** procp = (void **) &disp->Clear;
1513         snprintf(symboln, sizeof(symboln), "%sClear", symbol_prefix);
1514         *procp = dlsym(handle, symboln);
1515     }
1516
1517
1518     if(!disp->ClearAccum) {
1519         void ** procp = (void **) &disp->ClearAccum;
1520         snprintf(symboln, sizeof(symboln), "%sClearAccum", symbol_prefix);
1521         *procp = dlsym(handle, symboln);
1522     }
1523
1524
1525     if(!disp->ClearIndex) {
1526         void ** procp = (void **) &disp->ClearIndex;
1527         snprintf(symboln, sizeof(symboln), "%sClearIndex", symbol_prefix);
1528         *procp = dlsym(handle, symboln);
1529     }
1530
1531
1532     if(!disp->ClearColor) {
1533         void ** procp = (void **) &disp->ClearColor;
1534         snprintf(symboln, sizeof(symboln), "%sClearColor", symbol_prefix);
1535         *procp = dlsym(handle, symboln);
1536     }
1537
1538
1539     if(!disp->ClearStencil) {
1540         void ** procp = (void **) &disp->ClearStencil;
1541         snprintf(symboln, sizeof(symboln), "%sClearStencil", symbol_prefix);
1542         *procp = dlsym(handle, symboln);
1543     }
1544
1545
1546     if(!disp->ClearDepth) {
1547         void ** procp = (void **) &disp->ClearDepth;
1548         snprintf(symboln, sizeof(symboln), "%sClearDepth", symbol_prefix);
1549         *procp = dlsym(handle, symboln);
1550     }
1551
1552
1553     if(!disp->StencilMask) {
1554         void ** procp = (void **) &disp->StencilMask;
1555         snprintf(symboln, sizeof(symboln), "%sStencilMask", symbol_prefix);
1556         *procp = dlsym(handle, symboln);
1557     }
1558
1559
1560     if(!disp->ColorMask) {
1561         void ** procp = (void **) &disp->ColorMask;
1562         snprintf(symboln, sizeof(symboln), "%sColorMask", symbol_prefix);
1563         *procp = dlsym(handle, symboln);
1564     }
1565
1566
1567     if(!disp->DepthMask) {
1568         void ** procp = (void **) &disp->DepthMask;
1569         snprintf(symboln, sizeof(symboln), "%sDepthMask", symbol_prefix);
1570         *procp = dlsym(handle, symboln);
1571     }
1572
1573
1574     if(!disp->IndexMask) {
1575         void ** procp = (void **) &disp->IndexMask;
1576         snprintf(symboln, sizeof(symboln), "%sIndexMask", symbol_prefix);
1577         *procp = dlsym(handle, symboln);
1578     }
1579
1580
1581     if(!disp->Accum) {
1582         void ** procp = (void **) &disp->Accum;
1583         snprintf(symboln, sizeof(symboln), "%sAccum", symbol_prefix);
1584         *procp = dlsym(handle, symboln);
1585     }
1586
1587
1588     if(!disp->Disable) {
1589         void ** procp = (void **) &disp->Disable;
1590         snprintf(symboln, sizeof(symboln), "%sDisable", symbol_prefix);
1591         *procp = dlsym(handle, symboln);
1592     }
1593
1594
1595     if(!disp->Enable) {
1596         void ** procp = (void **) &disp->Enable;
1597         snprintf(symboln, sizeof(symboln), "%sEnable", symbol_prefix);
1598         *procp = dlsym(handle, symboln);
1599     }
1600
1601
1602     if(!disp->Finish) {
1603         void ** procp = (void **) &disp->Finish;
1604         snprintf(symboln, sizeof(symboln), "%sFinish", symbol_prefix);
1605         *procp = dlsym(handle, symboln);
1606     }
1607
1608
1609     if(!disp->Flush) {
1610         void ** procp = (void **) &disp->Flush;
1611         snprintf(symboln, sizeof(symboln), "%sFlush", symbol_prefix);
1612         *procp = dlsym(handle, symboln);
1613     }
1614
1615
1616     if(!disp->PopAttrib) {
1617         void ** procp = (void **) &disp->PopAttrib;
1618         snprintf(symboln, sizeof(symboln), "%sPopAttrib", symbol_prefix);
1619         *procp = dlsym(handle, symboln);
1620     }
1621
1622
1623     if(!disp->PushAttrib) {
1624         void ** procp = (void **) &disp->PushAttrib;
1625         snprintf(symboln, sizeof(symboln), "%sPushAttrib", symbol_prefix);
1626         *procp = dlsym(handle, symboln);
1627     }
1628
1629
1630     if(!disp->Map1d) {
1631         void ** procp = (void **) &disp->Map1d;
1632         snprintf(symboln, sizeof(symboln), "%sMap1d", symbol_prefix);
1633         *procp = dlsym(handle, symboln);
1634     }
1635
1636
1637     if(!disp->Map1f) {
1638         void ** procp = (void **) &disp->Map1f;
1639         snprintf(symboln, sizeof(symboln), "%sMap1f", symbol_prefix);
1640         *procp = dlsym(handle, symboln);
1641     }
1642
1643
1644     if(!disp->Map2d) {
1645         void ** procp = (void **) &disp->Map2d;
1646         snprintf(symboln, sizeof(symboln), "%sMap2d", symbol_prefix);
1647         *procp = dlsym(handle, symboln);
1648     }
1649
1650
1651     if(!disp->Map2f) {
1652         void ** procp = (void **) &disp->Map2f;
1653         snprintf(symboln, sizeof(symboln), "%sMap2f", symbol_prefix);
1654         *procp = dlsym(handle, symboln);
1655     }
1656
1657
1658     if(!disp->MapGrid1d) {
1659         void ** procp = (void **) &disp->MapGrid1d;
1660         snprintf(symboln, sizeof(symboln), "%sMapGrid1d", symbol_prefix);
1661         *procp = dlsym(handle, symboln);
1662     }
1663
1664
1665     if(!disp->MapGrid1f) {
1666         void ** procp = (void **) &disp->MapGrid1f;
1667         snprintf(symboln, sizeof(symboln), "%sMapGrid1f", symbol_prefix);
1668         *procp = dlsym(handle, symboln);
1669     }
1670
1671
1672     if(!disp->MapGrid2d) {
1673         void ** procp = (void **) &disp->MapGrid2d;
1674         snprintf(symboln, sizeof(symboln), "%sMapGrid2d", symbol_prefix);
1675         *procp = dlsym(handle, symboln);
1676     }
1677
1678
1679     if(!disp->MapGrid2f) {
1680         void ** procp = (void **) &disp->MapGrid2f;
1681         snprintf(symboln, sizeof(symboln), "%sMapGrid2f", symbol_prefix);
1682         *procp = dlsym(handle, symboln);
1683     }
1684
1685
1686     if(!disp->EvalCoord1d) {
1687         void ** procp = (void **) &disp->EvalCoord1d;
1688         snprintf(symboln, sizeof(symboln), "%sEvalCoord1d", symbol_prefix);
1689         *procp = dlsym(handle, symboln);
1690     }
1691
1692
1693     if(!disp->EvalCoord1dv) {
1694         void ** procp = (void **) &disp->EvalCoord1dv;
1695         snprintf(symboln, sizeof(symboln), "%sEvalCoord1dv", symbol_prefix);
1696         *procp = dlsym(handle, symboln);
1697     }
1698
1699
1700     if(!disp->EvalCoord1f) {
1701         void ** procp = (void **) &disp->EvalCoord1f;
1702         snprintf(symboln, sizeof(symboln), "%sEvalCoord1f", symbol_prefix);
1703         *procp = dlsym(handle, symboln);
1704     }
1705
1706
1707     if(!disp->EvalCoord1fv) {
1708         void ** procp = (void **) &disp->EvalCoord1fv;
1709         snprintf(symboln, sizeof(symboln), "%sEvalCoord1fv", symbol_prefix);
1710         *procp = dlsym(handle, symboln);
1711     }
1712
1713
1714     if(!disp->EvalCoord2d) {
1715         void ** procp = (void **) &disp->EvalCoord2d;
1716         snprintf(symboln, sizeof(symboln), "%sEvalCoord2d", symbol_prefix);
1717         *procp = dlsym(handle, symboln);
1718     }
1719
1720
1721     if(!disp->EvalCoord2dv) {
1722         void ** procp = (void **) &disp->EvalCoord2dv;
1723         snprintf(symboln, sizeof(symboln), "%sEvalCoord2dv", symbol_prefix);
1724         *procp = dlsym(handle, symboln);
1725     }
1726
1727
1728     if(!disp->EvalCoord2f) {
1729         void ** procp = (void **) &disp->EvalCoord2f;
1730         snprintf(symboln, sizeof(symboln), "%sEvalCoord2f", symbol_prefix);
1731         *procp = dlsym(handle, symboln);
1732     }
1733
1734
1735     if(!disp->EvalCoord2fv) {
1736         void ** procp = (void **) &disp->EvalCoord2fv;
1737         snprintf(symboln, sizeof(symboln), "%sEvalCoord2fv", symbol_prefix);
1738         *procp = dlsym(handle, symboln);
1739     }
1740
1741
1742     if(!disp->EvalMesh1) {
1743         void ** procp = (void **) &disp->EvalMesh1;
1744         snprintf(symboln, sizeof(symboln), "%sEvalMesh1", symbol_prefix);
1745         *procp = dlsym(handle, symboln);
1746     }
1747
1748
1749     if(!disp->EvalPoint1) {
1750         void ** procp = (void **) &disp->EvalPoint1;
1751         snprintf(symboln, sizeof(symboln), "%sEvalPoint1", symbol_prefix);
1752         *procp = dlsym(handle, symboln);
1753     }
1754
1755
1756     if(!disp->EvalMesh2) {
1757         void ** procp = (void **) &disp->EvalMesh2;
1758         snprintf(symboln, sizeof(symboln), "%sEvalMesh2", symbol_prefix);
1759         *procp = dlsym(handle, symboln);
1760     }
1761
1762
1763     if(!disp->EvalPoint2) {
1764         void ** procp = (void **) &disp->EvalPoint2;
1765         snprintf(symboln, sizeof(symboln), "%sEvalPoint2", symbol_prefix);
1766         *procp = dlsym(handle, symboln);
1767     }
1768
1769
1770     if(!disp->AlphaFunc) {
1771         void ** procp = (void **) &disp->AlphaFunc;
1772         snprintf(symboln, sizeof(symboln), "%sAlphaFunc", symbol_prefix);
1773         *procp = dlsym(handle, symboln);
1774     }
1775
1776
1777     if(!disp->BlendFunc) {
1778         void ** procp = (void **) &disp->BlendFunc;
1779         snprintf(symboln, sizeof(symboln), "%sBlendFunc", symbol_prefix);
1780         *procp = dlsym(handle, symboln);
1781     }
1782
1783
1784     if(!disp->LogicOp) {
1785         void ** procp = (void **) &disp->LogicOp;
1786         snprintf(symboln, sizeof(symboln), "%sLogicOp", symbol_prefix);
1787         *procp = dlsym(handle, symboln);
1788     }
1789
1790
1791     if(!disp->StencilFunc) {
1792         void ** procp = (void **) &disp->StencilFunc;
1793         snprintf(symboln, sizeof(symboln), "%sStencilFunc", symbol_prefix);
1794         *procp = dlsym(handle, symboln);
1795     }
1796
1797
1798     if(!disp->StencilOp) {
1799         void ** procp = (void **) &disp->StencilOp;
1800         snprintf(symboln, sizeof(symboln), "%sStencilOp", symbol_prefix);
1801         *procp = dlsym(handle, symboln);
1802     }
1803
1804
1805     if(!disp->DepthFunc) {
1806         void ** procp = (void **) &disp->DepthFunc;
1807         snprintf(symboln, sizeof(symboln), "%sDepthFunc", symbol_prefix);
1808         *procp = dlsym(handle, symboln);
1809     }
1810
1811
1812     if(!disp->PixelZoom) {
1813         void ** procp = (void **) &disp->PixelZoom;
1814         snprintf(symboln, sizeof(symboln), "%sPixelZoom", symbol_prefix);
1815         *procp = dlsym(handle, symboln);
1816     }
1817
1818
1819     if(!disp->PixelTransferf) {
1820         void ** procp = (void **) &disp->PixelTransferf;
1821         snprintf(symboln, sizeof(symboln), "%sPixelTransferf", symbol_prefix);
1822         *procp = dlsym(handle, symboln);
1823     }
1824
1825
1826     if(!disp->PixelTransferi) {
1827         void ** procp = (void **) &disp->PixelTransferi;
1828         snprintf(symboln, sizeof(symboln), "%sPixelTransferi", symbol_prefix);
1829         *procp = dlsym(handle, symboln);
1830     }
1831
1832
1833     if(!disp->PixelStoref) {
1834         void ** procp = (void **) &disp->PixelStoref;
1835         snprintf(symboln, sizeof(symboln), "%sPixelStoref", symbol_prefix);
1836         *procp = dlsym(handle, symboln);
1837     }
1838
1839
1840     if(!disp->PixelStorei) {
1841         void ** procp = (void **) &disp->PixelStorei;
1842         snprintf(symboln, sizeof(symboln), "%sPixelStorei", symbol_prefix);
1843         *procp = dlsym(handle, symboln);
1844     }
1845
1846
1847     if(!disp->PixelMapfv) {
1848         void ** procp = (void **) &disp->PixelMapfv;
1849         snprintf(symboln, sizeof(symboln), "%sPixelMapfv", symbol_prefix);
1850         *procp = dlsym(handle, symboln);
1851     }
1852
1853
1854     if(!disp->PixelMapuiv) {
1855         void ** procp = (void **) &disp->PixelMapuiv;
1856         snprintf(symboln, sizeof(symboln), "%sPixelMapuiv", symbol_prefix);
1857         *procp = dlsym(handle, symboln);
1858     }
1859
1860
1861     if(!disp->PixelMapusv) {
1862         void ** procp = (void **) &disp->PixelMapusv;
1863         snprintf(symboln, sizeof(symboln), "%sPixelMapusv", symbol_prefix);
1864         *procp = dlsym(handle, symboln);
1865     }
1866
1867
1868     if(!disp->ReadBuffer) {
1869         void ** procp = (void **) &disp->ReadBuffer;
1870         snprintf(symboln, sizeof(symboln), "%sReadBuffer", symbol_prefix);
1871         *procp = dlsym(handle, symboln);
1872     }
1873
1874
1875     if(!disp->CopyPixels) {
1876         void ** procp = (void **) &disp->CopyPixels;
1877         snprintf(symboln, sizeof(symboln), "%sCopyPixels", symbol_prefix);
1878         *procp = dlsym(handle, symboln);
1879     }
1880
1881
1882     if(!disp->ReadPixels) {
1883         void ** procp = (void **) &disp->ReadPixels;
1884         snprintf(symboln, sizeof(symboln), "%sReadPixels", symbol_prefix);
1885         *procp = dlsym(handle, symboln);
1886     }
1887
1888
1889     if(!disp->DrawPixels) {
1890         void ** procp = (void **) &disp->DrawPixels;
1891         snprintf(symboln, sizeof(symboln), "%sDrawPixels", symbol_prefix);
1892         *procp = dlsym(handle, symboln);
1893     }
1894
1895
1896     if(!disp->GetBooleanv) {
1897         void ** procp = (void **) &disp->GetBooleanv;
1898         snprintf(symboln, sizeof(symboln), "%sGetBooleanv", symbol_prefix);
1899         *procp = dlsym(handle, symboln);
1900     }
1901
1902
1903     if(!disp->GetClipPlane) {
1904         void ** procp = (void **) &disp->GetClipPlane;
1905         snprintf(symboln, sizeof(symboln), "%sGetClipPlane", symbol_prefix);
1906         *procp = dlsym(handle, symboln);
1907     }
1908
1909
1910     if(!disp->GetDoublev) {
1911         void ** procp = (void **) &disp->GetDoublev;
1912         snprintf(symboln, sizeof(symboln), "%sGetDoublev", symbol_prefix);
1913         *procp = dlsym(handle, symboln);
1914     }
1915
1916
1917     if(!disp->GetError) {
1918         void ** procp = (void **) &disp->GetError;
1919         snprintf(symboln, sizeof(symboln), "%sGetError", symbol_prefix);
1920         *procp = dlsym(handle, symboln);
1921     }
1922
1923
1924     if(!disp->GetFloatv) {
1925         void ** procp = (void **) &disp->GetFloatv;
1926         snprintf(symboln, sizeof(symboln), "%sGetFloatv", symbol_prefix);
1927         *procp = dlsym(handle, symboln);
1928     }
1929
1930
1931     if(!disp->GetIntegerv) {
1932         void ** procp = (void **) &disp->GetIntegerv;
1933         snprintf(symboln, sizeof(symboln), "%sGetIntegerv", symbol_prefix);
1934         *procp = dlsym(handle, symboln);
1935     }
1936
1937
1938     if(!disp->GetLightfv) {
1939         void ** procp = (void **) &disp->GetLightfv;
1940         snprintf(symboln, sizeof(symboln), "%sGetLightfv", symbol_prefix);
1941         *procp = dlsym(handle, symboln);
1942     }
1943
1944
1945     if(!disp->GetLightiv) {
1946         void ** procp = (void **) &disp->GetLightiv;
1947         snprintf(symboln, sizeof(symboln), "%sGetLightiv", symbol_prefix);
1948         *procp = dlsym(handle, symboln);
1949     }
1950
1951
1952     if(!disp->GetMapdv) {
1953         void ** procp = (void **) &disp->GetMapdv;
1954         snprintf(symboln, sizeof(symboln), "%sGetMapdv", symbol_prefix);
1955         *procp = dlsym(handle, symboln);
1956     }
1957
1958
1959     if(!disp->GetMapfv) {
1960         void ** procp = (void **) &disp->GetMapfv;
1961         snprintf(symboln, sizeof(symboln), "%sGetMapfv", symbol_prefix);
1962         *procp = dlsym(handle, symboln);
1963     }
1964
1965
1966     if(!disp->GetMapiv) {
1967         void ** procp = (void **) &disp->GetMapiv;
1968         snprintf(symboln, sizeof(symboln), "%sGetMapiv", symbol_prefix);
1969         *procp = dlsym(handle, symboln);
1970     }
1971
1972
1973     if(!disp->GetMaterialfv) {
1974         void ** procp = (void **) &disp->GetMaterialfv;
1975         snprintf(symboln, sizeof(symboln), "%sGetMaterialfv", symbol_prefix);
1976         *procp = dlsym(handle, symboln);
1977     }
1978
1979
1980     if(!disp->GetMaterialiv) {
1981         void ** procp = (void **) &disp->GetMaterialiv;
1982         snprintf(symboln, sizeof(symboln), "%sGetMaterialiv", symbol_prefix);
1983         *procp = dlsym(handle, symboln);
1984     }
1985
1986
1987     if(!disp->GetPixelMapfv) {
1988         void ** procp = (void **) &disp->GetPixelMapfv;
1989         snprintf(symboln, sizeof(symboln), "%sGetPixelMapfv", symbol_prefix);
1990         *procp = dlsym(handle, symboln);
1991     }
1992
1993
1994     if(!disp->GetPixelMapuiv) {
1995         void ** procp = (void **) &disp->GetPixelMapuiv;
1996         snprintf(symboln, sizeof(symboln), "%sGetPixelMapuiv", symbol_prefix);
1997         *procp = dlsym(handle, symboln);
1998     }
1999
2000
2001     if(!disp->GetPixelMapusv) {
2002         void ** procp = (void **) &disp->GetPixelMapusv;
2003         snprintf(symboln, sizeof(symboln), "%sGetPixelMapusv", symbol_prefix);
2004         *procp = dlsym(handle, symboln);
2005     }
2006
2007
2008     if(!disp->GetPolygonStipple) {
2009         void ** procp = (void **) &disp->GetPolygonStipple;
2010         snprintf(symboln, sizeof(symboln), "%sGetPolygonStipple", symbol_prefix);
2011         *procp = dlsym(handle, symboln);
2012     }
2013
2014
2015     if(!disp->GetString) {
2016         void ** procp = (void **) &disp->GetString;
2017         snprintf(symboln, sizeof(symboln), "%sGetString", symbol_prefix);
2018         *procp = dlsym(handle, symboln);
2019     }
2020
2021
2022     if(!disp->GetTexEnvfv) {
2023         void ** procp = (void **) &disp->GetTexEnvfv;
2024         snprintf(symboln, sizeof(symboln), "%sGetTexEnvfv", symbol_prefix);
2025         *procp = dlsym(handle, symboln);
2026     }
2027
2028
2029     if(!disp->GetTexEnviv) {
2030         void ** procp = (void **) &disp->GetTexEnviv;
2031         snprintf(symboln, sizeof(symboln), "%sGetTexEnviv", symbol_prefix);
2032         *procp = dlsym(handle, symboln);
2033     }
2034
2035
2036     if(!disp->GetTexGendv) {
2037         void ** procp = (void **) &disp->GetTexGendv;
2038         snprintf(symboln, sizeof(symboln), "%sGetTexGendv", symbol_prefix);
2039         *procp = dlsym(handle, symboln);
2040     }
2041
2042
2043     if(!disp->GetTexGenfv) {
2044         void ** procp = (void **) &disp->GetTexGenfv;
2045         snprintf(symboln, sizeof(symboln), "%sGetTexGenfv", symbol_prefix);
2046         *procp = dlsym(handle, symboln);
2047     }
2048
2049
2050     if(!disp->GetTexGeniv) {
2051         void ** procp = (void **) &disp->GetTexGeniv;
2052         snprintf(symboln, sizeof(symboln), "%sGetTexGeniv", symbol_prefix);
2053         *procp = dlsym(handle, symboln);
2054     }
2055
2056
2057     if(!disp->GetTexImage) {
2058         void ** procp = (void **) &disp->GetTexImage;
2059         snprintf(symboln, sizeof(symboln), "%sGetTexImage", symbol_prefix);
2060         *procp = dlsym(handle, symboln);
2061     }
2062
2063
2064     if(!disp->GetTexParameterfv) {
2065         void ** procp = (void **) &disp->GetTexParameterfv;
2066         snprintf(symboln, sizeof(symboln), "%sGetTexParameterfv", symbol_prefix);
2067         *procp = dlsym(handle, symboln);
2068     }
2069
2070
2071     if(!disp->GetTexParameteriv) {
2072         void ** procp = (void **) &disp->GetTexParameteriv;
2073         snprintf(symboln, sizeof(symboln), "%sGetTexParameteriv", symbol_prefix);
2074         *procp = dlsym(handle, symboln);
2075     }
2076
2077
2078     if(!disp->GetTexLevelParameterfv) {
2079         void ** procp = (void **) &disp->GetTexLevelParameterfv;
2080         snprintf(symboln, sizeof(symboln), "%sGetTexLevelParameterfv", symbol_prefix);
2081         *procp = dlsym(handle, symboln);
2082     }
2083
2084
2085     if(!disp->GetTexLevelParameteriv) {
2086         void ** procp = (void **) &disp->GetTexLevelParameteriv;
2087         snprintf(symboln, sizeof(symboln), "%sGetTexLevelParameteriv", symbol_prefix);
2088         *procp = dlsym(handle, symboln);
2089     }
2090
2091
2092     if(!disp->IsEnabled) {
2093         void ** procp = (void **) &disp->IsEnabled;
2094         snprintf(symboln, sizeof(symboln), "%sIsEnabled", symbol_prefix);
2095         *procp = dlsym(handle, symboln);
2096     }
2097
2098
2099     if(!disp->IsList) {
2100         void ** procp = (void **) &disp->IsList;
2101         snprintf(symboln, sizeof(symboln), "%sIsList", symbol_prefix);
2102         *procp = dlsym(handle, symboln);
2103     }
2104
2105
2106     if(!disp->DepthRange) {
2107         void ** procp = (void **) &disp->DepthRange;
2108         snprintf(symboln, sizeof(symboln), "%sDepthRange", symbol_prefix);
2109         *procp = dlsym(handle, symboln);
2110     }
2111
2112
2113     if(!disp->Frustum) {
2114         void ** procp = (void **) &disp->Frustum;
2115         snprintf(symboln, sizeof(symboln), "%sFrustum", symbol_prefix);
2116         *procp = dlsym(handle, symboln);
2117     }
2118
2119
2120     if(!disp->LoadIdentity) {
2121         void ** procp = (void **) &disp->LoadIdentity;
2122         snprintf(symboln, sizeof(symboln), "%sLoadIdentity", symbol_prefix);
2123         *procp = dlsym(handle, symboln);
2124     }
2125
2126
2127     if(!disp->LoadMatrixf) {
2128         void ** procp = (void **) &disp->LoadMatrixf;
2129         snprintf(symboln, sizeof(symboln), "%sLoadMatrixf", symbol_prefix);
2130         *procp = dlsym(handle, symboln);
2131     }
2132
2133
2134     if(!disp->LoadMatrixd) {
2135         void ** procp = (void **) &disp->LoadMatrixd;
2136         snprintf(symboln, sizeof(symboln), "%sLoadMatrixd", symbol_prefix);
2137         *procp = dlsym(handle, symboln);
2138     }
2139
2140
2141     if(!disp->MatrixMode) {
2142         void ** procp = (void **) &disp->MatrixMode;
2143         snprintf(symboln, sizeof(symboln), "%sMatrixMode", symbol_prefix);
2144         *procp = dlsym(handle, symboln);
2145     }
2146
2147
2148     if(!disp->MultMatrixf) {
2149         void ** procp = (void **) &disp->MultMatrixf;
2150         snprintf(symboln, sizeof(symboln), "%sMultMatrixf", symbol_prefix);
2151         *procp = dlsym(handle, symboln);
2152     }
2153
2154
2155     if(!disp->MultMatrixd) {
2156         void ** procp = (void **) &disp->MultMatrixd;
2157         snprintf(symboln, sizeof(symboln), "%sMultMatrixd", symbol_prefix);
2158         *procp = dlsym(handle, symboln);
2159     }
2160
2161
2162     if(!disp->Ortho) {
2163         void ** procp = (void **) &disp->Ortho;
2164         snprintf(symboln, sizeof(symboln), "%sOrtho", symbol_prefix);
2165         *procp = dlsym(handle, symboln);
2166     }
2167
2168
2169     if(!disp->PopMatrix) {
2170         void ** procp = (void **) &disp->PopMatrix;
2171         snprintf(symboln, sizeof(symboln), "%sPopMatrix", symbol_prefix);
2172         *procp = dlsym(handle, symboln);
2173     }
2174
2175
2176     if(!disp->PushMatrix) {
2177         void ** procp = (void **) &disp->PushMatrix;
2178         snprintf(symboln, sizeof(symboln), "%sPushMatrix", symbol_prefix);
2179         *procp = dlsym(handle, symboln);
2180     }
2181
2182
2183     if(!disp->Rotated) {
2184         void ** procp = (void **) &disp->Rotated;
2185         snprintf(symboln, sizeof(symboln), "%sRotated", symbol_prefix);
2186         *procp = dlsym(handle, symboln);
2187     }
2188
2189
2190     if(!disp->Rotatef) {
2191         void ** procp = (void **) &disp->Rotatef;
2192         snprintf(symboln, sizeof(symboln), "%sRotatef", symbol_prefix);
2193         *procp = dlsym(handle, symboln);
2194     }
2195
2196
2197     if(!disp->Scaled) {
2198         void ** procp = (void **) &disp->Scaled;
2199         snprintf(symboln, sizeof(symboln), "%sScaled", symbol_prefix);
2200         *procp = dlsym(handle, symboln);
2201     }
2202
2203
2204     if(!disp->Scalef) {
2205         void ** procp = (void **) &disp->Scalef;
2206         snprintf(symboln, sizeof(symboln), "%sScalef", symbol_prefix);
2207         *procp = dlsym(handle, symboln);
2208     }
2209
2210
2211     if(!disp->Translated) {
2212         void ** procp = (void **) &disp->Translated;
2213         snprintf(symboln, sizeof(symboln), "%sTranslated", symbol_prefix);
2214         *procp = dlsym(handle, symboln);
2215     }
2216
2217
2218     if(!disp->Translatef) {
2219         void ** procp = (void **) &disp->Translatef;
2220         snprintf(symboln, sizeof(symboln), "%sTranslatef", symbol_prefix);
2221         *procp = dlsym(handle, symboln);
2222     }
2223
2224
2225     if(!disp->Viewport) {
2226         void ** procp = (void **) &disp->Viewport;
2227         snprintf(symboln, sizeof(symboln), "%sViewport", symbol_prefix);
2228         *procp = dlsym(handle, symboln);
2229     }
2230
2231
2232     if(!disp->ArrayElement) {
2233         void ** procp = (void **) &disp->ArrayElement;
2234         snprintf(symboln, sizeof(symboln), "%sArrayElement", symbol_prefix);
2235         *procp = dlsym(handle, symboln);
2236     }
2237
2238
2239     if(!disp->ArrayElement) {
2240         void ** procp = (void **) &disp->ArrayElement;
2241         snprintf(symboln, sizeof(symboln), "%sArrayElementEXT", symbol_prefix);
2242         *procp = dlsym(handle, symboln);
2243     }
2244
2245
2246     if(!disp->BindTexture) {
2247         void ** procp = (void **) &disp->BindTexture;
2248         snprintf(symboln, sizeof(symboln), "%sBindTexture", symbol_prefix);
2249         *procp = dlsym(handle, symboln);
2250     }
2251
2252
2253     if(!disp->BindTexture) {
2254         void ** procp = (void **) &disp->BindTexture;
2255         snprintf(symboln, sizeof(symboln), "%sBindTextureEXT", symbol_prefix);
2256         *procp = dlsym(handle, symboln);
2257     }
2258
2259
2260     if(!disp->ColorPointer) {
2261         void ** procp = (void **) &disp->ColorPointer;
2262         snprintf(symboln, sizeof(symboln), "%sColorPointer", symbol_prefix);
2263         *procp = dlsym(handle, symboln);
2264     }
2265
2266
2267     if(!disp->DisableClientState) {
2268         void ** procp = (void **) &disp->DisableClientState;
2269         snprintf(symboln, sizeof(symboln), "%sDisableClientState", symbol_prefix);
2270         *procp = dlsym(handle, symboln);
2271     }
2272
2273
2274     if(!disp->DrawArrays) {
2275         void ** procp = (void **) &disp->DrawArrays;
2276         snprintf(symboln, sizeof(symboln), "%sDrawArrays", symbol_prefix);
2277         *procp = dlsym(handle, symboln);
2278     }
2279
2280
2281     if(!disp->DrawArrays) {
2282         void ** procp = (void **) &disp->DrawArrays;
2283         snprintf(symboln, sizeof(symboln), "%sDrawArraysEXT", symbol_prefix);
2284         *procp = dlsym(handle, symboln);
2285     }
2286
2287
2288     if(!disp->DrawElements) {
2289         void ** procp = (void **) &disp->DrawElements;
2290         snprintf(symboln, sizeof(symboln), "%sDrawElements", symbol_prefix);
2291         *procp = dlsym(handle, symboln);
2292     }
2293
2294
2295     if(!disp->EdgeFlagPointer) {
2296         void ** procp = (void **) &disp->EdgeFlagPointer;
2297         snprintf(symboln, sizeof(symboln), "%sEdgeFlagPointer", symbol_prefix);
2298         *procp = dlsym(handle, symboln);
2299     }
2300
2301
2302     if(!disp->EnableClientState) {
2303         void ** procp = (void **) &disp->EnableClientState;
2304         snprintf(symboln, sizeof(symboln), "%sEnableClientState", symbol_prefix);
2305         *procp = dlsym(handle, symboln);
2306     }
2307
2308
2309     if(!disp->IndexPointer) {
2310         void ** procp = (void **) &disp->IndexPointer;
2311         snprintf(symboln, sizeof(symboln), "%sIndexPointer", symbol_prefix);
2312         *procp = dlsym(handle, symboln);
2313     }
2314
2315
2316     if(!disp->Indexub) {
2317         void ** procp = (void **) &disp->Indexub;
2318         snprintf(symboln, sizeof(symboln), "%sIndexub", symbol_prefix);
2319         *procp = dlsym(handle, symboln);
2320     }
2321
2322
2323     if(!disp->Indexubv) {
2324         void ** procp = (void **) &disp->Indexubv;
2325         snprintf(symboln, sizeof(symboln), "%sIndexubv", symbol_prefix);
2326         *procp = dlsym(handle, symboln);
2327     }
2328
2329
2330     if(!disp->InterleavedArrays) {
2331         void ** procp = (void **) &disp->InterleavedArrays;
2332         snprintf(symboln, sizeof(symboln), "%sInterleavedArrays", symbol_prefix);
2333         *procp = dlsym(handle, symboln);
2334     }
2335
2336
2337     if(!disp->NormalPointer) {
2338         void ** procp = (void **) &disp->NormalPointer;
2339         snprintf(symboln, sizeof(symboln), "%sNormalPointer", symbol_prefix);
2340         *procp = dlsym(handle, symboln);
2341     }
2342
2343
2344     if(!disp->PolygonOffset) {
2345         void ** procp = (void **) &disp->PolygonOffset;
2346         snprintf(symboln, sizeof(symboln), "%sPolygonOffset", symbol_prefix);
2347         *procp = dlsym(handle, symboln);
2348     }
2349
2350
2351     if(!disp->TexCoordPointer) {
2352         void ** procp = (void **) &disp->TexCoordPointer;
2353         snprintf(symboln, sizeof(symboln), "%sTexCoordPointer", symbol_prefix);
2354         *procp = dlsym(handle, symboln);
2355     }
2356
2357
2358     if(!disp->VertexPointer) {
2359         void ** procp = (void **) &disp->VertexPointer;
2360         snprintf(symboln, sizeof(symboln), "%sVertexPointer", symbol_prefix);
2361         *procp = dlsym(handle, symboln);
2362     }
2363
2364
2365     if(!disp->AreTexturesResident) {
2366         void ** procp = (void **) &disp->AreTexturesResident;
2367         snprintf(symboln, sizeof(symboln), "%sAreTexturesResident", symbol_prefix);
2368         *procp = dlsym(handle, symboln);
2369     }
2370
2371
2372     if(!disp->AreTexturesResident) {
2373         void ** procp = (void **) &disp->AreTexturesResident;
2374         snprintf(symboln, sizeof(symboln), "%sAreTexturesResidentEXT", symbol_prefix);
2375         *procp = dlsym(handle, symboln);
2376     }
2377
2378
2379     if(!disp->CopyTexImage1D) {
2380         void ** procp = (void **) &disp->CopyTexImage1D;
2381         snprintf(symboln, sizeof(symboln), "%sCopyTexImage1D", symbol_prefix);
2382         *procp = dlsym(handle, symboln);
2383     }
2384
2385
2386     if(!disp->CopyTexImage1D) {
2387         void ** procp = (void **) &disp->CopyTexImage1D;
2388         snprintf(symboln, sizeof(symboln), "%sCopyTexImage1DEXT", symbol_prefix);
2389         *procp = dlsym(handle, symboln);
2390     }
2391
2392
2393     if(!disp->CopyTexImage2D) {
2394         void ** procp = (void **) &disp->CopyTexImage2D;
2395         snprintf(symboln, sizeof(symboln), "%sCopyTexImage2D", symbol_prefix);
2396         *procp = dlsym(handle, symboln);
2397     }
2398
2399
2400     if(!disp->CopyTexImage2D) {
2401         void ** procp = (void **) &disp->CopyTexImage2D;
2402         snprintf(symboln, sizeof(symboln), "%sCopyTexImage2DEXT", symbol_prefix);
2403         *procp = dlsym(handle, symboln);
2404     }
2405
2406
2407     if(!disp->CopyTexSubImage1D) {
2408         void ** procp = (void **) &disp->CopyTexSubImage1D;
2409         snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage1D", symbol_prefix);
2410         *procp = dlsym(handle, symboln);
2411     }
2412
2413
2414     if(!disp->CopyTexSubImage1D) {
2415         void ** procp = (void **) &disp->CopyTexSubImage1D;
2416         snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage1DEXT", symbol_prefix);
2417         *procp = dlsym(handle, symboln);
2418     }
2419
2420
2421     if(!disp->CopyTexSubImage2D) {
2422         void ** procp = (void **) &disp->CopyTexSubImage2D;
2423         snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage2D", symbol_prefix);
2424         *procp = dlsym(handle, symboln);
2425     }
2426
2427
2428     if(!disp->CopyTexSubImage2D) {
2429         void ** procp = (void **) &disp->CopyTexSubImage2D;
2430         snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage2DEXT", symbol_prefix);
2431         *procp = dlsym(handle, symboln);
2432     }
2433
2434
2435     if(!disp->DeleteTextures) {
2436         void ** procp = (void **) &disp->DeleteTextures;
2437         snprintf(symboln, sizeof(symboln), "%sDeleteTextures", symbol_prefix);
2438         *procp = dlsym(handle, symboln);
2439     }
2440
2441
2442     if(!disp->DeleteTextures) {
2443         void ** procp = (void **) &disp->DeleteTextures;
2444         snprintf(symboln, sizeof(symboln), "%sDeleteTexturesEXT", symbol_prefix);
2445         *procp = dlsym(handle, symboln);
2446     }
2447
2448
2449     if(!disp->GenTextures) {
2450         void ** procp = (void **) &disp->GenTextures;
2451         snprintf(symboln, sizeof(symboln), "%sGenTextures", symbol_prefix);
2452         *procp = dlsym(handle, symboln);
2453     }
2454
2455
2456     if(!disp->GenTextures) {
2457         void ** procp = (void **) &disp->GenTextures;
2458         snprintf(symboln, sizeof(symboln), "%sGenTexturesEXT", symbol_prefix);
2459         *procp = dlsym(handle, symboln);
2460     }
2461
2462
2463     if(!disp->GetPointerv) {
2464         void ** procp = (void **) &disp->GetPointerv;
2465         snprintf(symboln, sizeof(symboln), "%sGetPointerv", symbol_prefix);
2466         *procp = dlsym(handle, symboln);
2467     }
2468
2469
2470     if(!disp->GetPointerv) {
2471         void ** procp = (void **) &disp->GetPointerv;
2472         snprintf(symboln, sizeof(symboln), "%sGetPointervEXT", symbol_prefix);
2473         *procp = dlsym(handle, symboln);
2474     }
2475
2476
2477     if(!disp->IsTexture) {
2478         void ** procp = (void **) &disp->IsTexture;
2479         snprintf(symboln, sizeof(symboln), "%sIsTexture", symbol_prefix);
2480         *procp = dlsym(handle, symboln);
2481     }
2482
2483
2484     if(!disp->IsTexture) {
2485         void ** procp = (void **) &disp->IsTexture;
2486         snprintf(symboln, sizeof(symboln), "%sIsTextureEXT", symbol_prefix);
2487         *procp = dlsym(handle, symboln);
2488     }
2489
2490
2491     if(!disp->PrioritizeTextures) {
2492         void ** procp = (void **) &disp->PrioritizeTextures;
2493         snprintf(symboln, sizeof(symboln), "%sPrioritizeTextures", symbol_prefix);
2494         *procp = dlsym(handle, symboln);
2495     }
2496
2497
2498     if(!disp->PrioritizeTextures) {
2499         void ** procp = (void **) &disp->PrioritizeTextures;
2500         snprintf(symboln, sizeof(symboln), "%sPrioritizeTexturesEXT", symbol_prefix);
2501         *procp = dlsym(handle, symboln);
2502     }
2503
2504
2505     if(!disp->TexSubImage1D) {
2506         void ** procp = (void **) &disp->TexSubImage1D;
2507         snprintf(symboln, sizeof(symboln), "%sTexSubImage1D", symbol_prefix);
2508         *procp = dlsym(handle, symboln);
2509     }
2510
2511
2512     if(!disp->TexSubImage1D) {
2513         void ** procp = (void **) &disp->TexSubImage1D;
2514         snprintf(symboln, sizeof(symboln), "%sTexSubImage1DEXT", symbol_prefix);
2515         *procp = dlsym(handle, symboln);
2516     }
2517
2518
2519     if(!disp->TexSubImage2D) {
2520         void ** procp = (void **) &disp->TexSubImage2D;
2521         snprintf(symboln, sizeof(symboln), "%sTexSubImage2D", symbol_prefix);
2522         *procp = dlsym(handle, symboln);
2523     }
2524
2525
2526     if(!disp->TexSubImage2D) {
2527         void ** procp = (void **) &disp->TexSubImage2D;
2528         snprintf(symboln, sizeof(symboln), "%sTexSubImage2DEXT", symbol_prefix);
2529         *procp = dlsym(handle, symboln);
2530     }
2531
2532
2533     if(!disp->PopClientAttrib) {
2534         void ** procp = (void **) &disp->PopClientAttrib;
2535         snprintf(symboln, sizeof(symboln), "%sPopClientAttrib", symbol_prefix);
2536         *procp = dlsym(handle, symboln);
2537     }
2538
2539
2540     if(!disp->PushClientAttrib) {
2541         void ** procp = (void **) &disp->PushClientAttrib;
2542         snprintf(symboln, sizeof(symboln), "%sPushClientAttrib", symbol_prefix);
2543         *procp = dlsym(handle, symboln);
2544     }
2545
2546
2547     if(!disp->BlendColor) {
2548         void ** procp = (void **) &disp->BlendColor;
2549         snprintf(symboln, sizeof(symboln), "%sBlendColor", symbol_prefix);
2550         *procp = dlsym(handle, symboln);
2551     }
2552
2553
2554     if(!disp->BlendColor) {
2555         void ** procp = (void **) &disp->BlendColor;
2556         snprintf(symboln, sizeof(symboln), "%sBlendColorEXT", symbol_prefix);
2557         *procp = dlsym(handle, symboln);
2558     }
2559
2560
2561     if(!disp->BlendEquation) {
2562         void ** procp = (void **) &disp->BlendEquation;
2563         snprintf(symboln, sizeof(symboln), "%sBlendEquation", symbol_prefix);
2564         *procp = dlsym(handle, symboln);
2565     }
2566
2567
2568     if(!disp->BlendEquation) {
2569         void ** procp = (void **) &disp->BlendEquation;
2570         snprintf(symboln, sizeof(symboln), "%sBlendEquationEXT", symbol_prefix);
2571         *procp = dlsym(handle, symboln);
2572     }
2573
2574
2575     if(!disp->DrawRangeElements) {
2576         void ** procp = (void **) &disp->DrawRangeElements;
2577         snprintf(symboln, sizeof(symboln), "%sDrawRangeElements", symbol_prefix);
2578         *procp = dlsym(handle, symboln);
2579     }
2580
2581
2582     if(!disp->DrawRangeElements) {
2583         void ** procp = (void **) &disp->DrawRangeElements;
2584         snprintf(symboln, sizeof(symboln), "%sDrawRangeElementsEXT", symbol_prefix);
2585         *procp = dlsym(handle, symboln);
2586     }
2587
2588
2589     if(!disp->ColorTable) {
2590         void ** procp = (void **) &disp->ColorTable;
2591         snprintf(symboln, sizeof(symboln), "%sColorTable", symbol_prefix);
2592         *procp = dlsym(handle, symboln);
2593     }
2594
2595
2596     if(!disp->ColorTable) {
2597         void ** procp = (void **) &disp->ColorTable;
2598         snprintf(symboln, sizeof(symboln), "%sColorTableSGI", symbol_prefix);
2599         *procp = dlsym(handle, symboln);
2600     }
2601
2602
2603     if(!disp->ColorTable) {
2604         void ** procp = (void **) &disp->ColorTable;
2605         snprintf(symboln, sizeof(symboln), "%sColorTableEXT", symbol_prefix);
2606         *procp = dlsym(handle, symboln);
2607     }
2608
2609
2610     if(!disp->ColorTableParameterfv) {
2611         void ** procp = (void **) &disp->ColorTableParameterfv;
2612         snprintf(symboln, sizeof(symboln), "%sColorTableParameterfv", symbol_prefix);
2613         *procp = dlsym(handle, symboln);
2614     }
2615
2616
2617     if(!disp->ColorTableParameterfv) {
2618         void ** procp = (void **) &disp->ColorTableParameterfv;
2619         snprintf(symboln, sizeof(symboln), "%sColorTableParameterfvSGI", symbol_prefix);
2620         *procp = dlsym(handle, symboln);
2621     }
2622
2623
2624     if(!disp->ColorTableParameteriv) {
2625         void ** procp = (void **) &disp->ColorTableParameteriv;
2626         snprintf(symboln, sizeof(symboln), "%sColorTableParameteriv", symbol_prefix);
2627         *procp = dlsym(handle, symboln);
2628     }
2629
2630
2631     if(!disp->ColorTableParameteriv) {
2632         void ** procp = (void **) &disp->ColorTableParameteriv;
2633         snprintf(symboln, sizeof(symboln), "%sColorTableParameterivSGI", symbol_prefix);
2634         *procp = dlsym(handle, symboln);
2635     }
2636
2637
2638     if(!disp->CopyColorTable) {
2639         void ** procp = (void **) &disp->CopyColorTable;
2640         snprintf(symboln, sizeof(symboln), "%sCopyColorTable", symbol_prefix);
2641         *procp = dlsym(handle, symboln);
2642     }
2643
2644
2645     if(!disp->CopyColorTable) {
2646         void ** procp = (void **) &disp->CopyColorTable;
2647         snprintf(symboln, sizeof(symboln), "%sCopyColorTableSGI", symbol_prefix);
2648         *procp = dlsym(handle, symboln);
2649     }
2650
2651
2652     if(!disp->GetColorTable) {
2653         void ** procp = (void **) &disp->GetColorTable;
2654         snprintf(symboln, sizeof(symboln), "%sGetColorTable", symbol_prefix);
2655         *procp = dlsym(handle, symboln);
2656     }
2657
2658
2659     if(!disp->GetColorTable) {
2660         void ** procp = (void **) &disp->GetColorTable;
2661         snprintf(symboln, sizeof(symboln), "%sGetColorTableSGI", symbol_prefix);
2662         *procp = dlsym(handle, symboln);
2663     }
2664
2665
2666     if(!disp->GetColorTable) {
2667         void ** procp = (void **) &disp->GetColorTable;
2668         snprintf(symboln, sizeof(symboln), "%sGetColorTableEXT", symbol_prefix);
2669         *procp = dlsym(handle, symboln);
2670     }
2671
2672
2673     if(!disp->GetColorTableParameterfv) {
2674         void ** procp = (void **) &disp->GetColorTableParameterfv;
2675         snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterfv", symbol_prefix);
2676         *procp = dlsym(handle, symboln);
2677     }
2678
2679
2680     if(!disp->GetColorTableParameterfv) {
2681         void ** procp = (void **) &disp->GetColorTableParameterfv;
2682         snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterfvSGI", symbol_prefix);
2683         *procp = dlsym(handle, symboln);
2684     }
2685
2686
2687     if(!disp->GetColorTableParameterfv) {
2688         void ** procp = (void **) &disp->GetColorTableParameterfv;
2689         snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterfvEXT", symbol_prefix);
2690         *procp = dlsym(handle, symboln);
2691     }
2692
2693
2694     if(!disp->GetColorTableParameteriv) {
2695         void ** procp = (void **) &disp->GetColorTableParameteriv;
2696         snprintf(symboln, sizeof(symboln), "%sGetColorTableParameteriv", symbol_prefix);
2697         *procp = dlsym(handle, symboln);
2698     }
2699
2700
2701     if(!disp->GetColorTableParameteriv) {
2702         void ** procp = (void **) &disp->GetColorTableParameteriv;
2703         snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterivSGI", symbol_prefix);
2704         *procp = dlsym(handle, symboln);
2705     }
2706
2707
2708     if(!disp->GetColorTableParameteriv) {
2709         void ** procp = (void **) &disp->GetColorTableParameteriv;
2710         snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterivEXT", symbol_prefix);
2711         *procp = dlsym(handle, symboln);
2712     }
2713
2714
2715     if(!disp->ColorSubTable) {
2716         void ** procp = (void **) &disp->ColorSubTable;
2717         snprintf(symboln, sizeof(symboln), "%sColorSubTable", symbol_prefix);
2718         *procp = dlsym(handle, symboln);
2719     }
2720
2721
2722     if(!disp->ColorSubTable) {
2723         void ** procp = (void **) &disp->ColorSubTable;
2724         snprintf(symboln, sizeof(symboln), "%sColorSubTableEXT", symbol_prefix);
2725         *procp = dlsym(handle, symboln);
2726     }
2727
2728
2729     if(!disp->CopyColorSubTable) {
2730         void ** procp = (void **) &disp->CopyColorSubTable;
2731         snprintf(symboln, sizeof(symboln), "%sCopyColorSubTable", symbol_prefix);
2732         *procp = dlsym(handle, symboln);
2733     }
2734
2735
2736     if(!disp->CopyColorSubTable) {
2737         void ** procp = (void **) &disp->CopyColorSubTable;
2738         snprintf(symboln, sizeof(symboln), "%sCopyColorSubTableEXT", symbol_prefix);
2739         *procp = dlsym(handle, symboln);
2740     }
2741
2742
2743     if(!disp->ConvolutionFilter1D) {
2744         void ** procp = (void **) &disp->ConvolutionFilter1D;
2745         snprintf(symboln, sizeof(symboln), "%sConvolutionFilter1D", symbol_prefix);
2746         *procp = dlsym(handle, symboln);
2747     }
2748
2749
2750     if(!disp->ConvolutionFilter1D) {
2751         void ** procp = (void **) &disp->ConvolutionFilter1D;
2752         snprintf(symboln, sizeof(symboln), "%sConvolutionFilter1DEXT", symbol_prefix);
2753         *procp = dlsym(handle, symboln);
2754     }
2755
2756
2757     if(!disp->ConvolutionFilter2D) {
2758         void ** procp = (void **) &disp->ConvolutionFilter2D;
2759         snprintf(symboln, sizeof(symboln), "%sConvolutionFilter2D", symbol_prefix);
2760         *procp = dlsym(handle, symboln);
2761     }
2762
2763
2764     if(!disp->ConvolutionFilter2D) {
2765         void ** procp = (void **) &disp->ConvolutionFilter2D;
2766         snprintf(symboln, sizeof(symboln), "%sConvolutionFilter2DEXT", symbol_prefix);
2767         *procp = dlsym(handle, symboln);
2768     }
2769
2770
2771     if(!disp->ConvolutionParameterf) {
2772         void ** procp = (void **) &disp->ConvolutionParameterf;
2773         snprintf(symboln, sizeof(symboln), "%sConvolutionParameterf", symbol_prefix);
2774         *procp = dlsym(handle, symboln);
2775     }
2776
2777
2778     if(!disp->ConvolutionParameterf) {
2779         void ** procp = (void **) &disp->ConvolutionParameterf;
2780         snprintf(symboln, sizeof(symboln), "%sConvolutionParameterfEXT", symbol_prefix);
2781         *procp = dlsym(handle, symboln);
2782     }
2783
2784
2785     if(!disp->ConvolutionParameterfv) {
2786         void ** procp = (void **) &disp->ConvolutionParameterfv;
2787         snprintf(symboln, sizeof(symboln), "%sConvolutionParameterfv", symbol_prefix);
2788         *procp = dlsym(handle, symboln);
2789     }
2790
2791
2792     if(!disp->ConvolutionParameterfv) {
2793         void ** procp = (void **) &disp->ConvolutionParameterfv;
2794         snprintf(symboln, sizeof(symboln), "%sConvolutionParameterfvEXT", symbol_prefix);
2795         *procp = dlsym(handle, symboln);
2796     }
2797
2798
2799     if(!disp->ConvolutionParameteri) {
2800         void ** procp = (void **) &disp->ConvolutionParameteri;
2801         snprintf(symboln, sizeof(symboln), "%sConvolutionParameteri", symbol_prefix);
2802         *procp = dlsym(handle, symboln);
2803     }
2804
2805
2806     if(!disp->ConvolutionParameteri) {
2807         void ** procp = (void **) &disp->ConvolutionParameteri;
2808         snprintf(symboln, sizeof(symboln), "%sConvolutionParameteriEXT", symbol_prefix);
2809         *procp = dlsym(handle, symboln);
2810     }
2811
2812
2813     if(!disp->ConvolutionParameteriv) {
2814         void ** procp = (void **) &disp->ConvolutionParameteriv;
2815         snprintf(symboln, sizeof(symboln), "%sConvolutionParameteriv", symbol_prefix);
2816         *procp = dlsym(handle, symboln);
2817     }
2818
2819
2820     if(!disp->ConvolutionParameteriv) {
2821         void ** procp = (void **) &disp->ConvolutionParameteriv;
2822         snprintf(symboln, sizeof(symboln), "%sConvolutionParameterivEXT", symbol_prefix);
2823         *procp = dlsym(handle, symboln);
2824     }
2825
2826
2827     if(!disp->CopyConvolutionFilter1D) {
2828         void ** procp = (void **) &disp->CopyConvolutionFilter1D;
2829         snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter1D", symbol_prefix);
2830         *procp = dlsym(handle, symboln);
2831     }
2832
2833
2834     if(!disp->CopyConvolutionFilter1D) {
2835         void ** procp = (void **) &disp->CopyConvolutionFilter1D;
2836         snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter1DEXT", symbol_prefix);
2837         *procp = dlsym(handle, symboln);
2838     }
2839
2840
2841     if(!disp->CopyConvolutionFilter2D) {
2842         void ** procp = (void **) &disp->CopyConvolutionFilter2D;
2843         snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter2D", symbol_prefix);
2844         *procp = dlsym(handle, symboln);
2845     }
2846
2847
2848     if(!disp->CopyConvolutionFilter2D) {
2849         void ** procp = (void **) &disp->CopyConvolutionFilter2D;
2850         snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter2DEXT", symbol_prefix);
2851         *procp = dlsym(handle, symboln);
2852     }
2853
2854
2855     if(!disp->GetConvolutionFilter) {
2856         void ** procp = (void **) &disp->GetConvolutionFilter;
2857         snprintf(symboln, sizeof(symboln), "%sGetConvolutionFilter", symbol_prefix);
2858         *procp = dlsym(handle, symboln);
2859     }
2860
2861
2862     if(!disp->GetConvolutionFilter) {
2863         void ** procp = (void **) &disp->GetConvolutionFilter;
2864         snprintf(symboln, sizeof(symboln), "%sGetConvolutionFilterEXT", symbol_prefix);
2865         *procp = dlsym(handle, symboln);
2866     }
2867
2868
2869     if(!disp->GetConvolutionParameterfv) {
2870         void ** procp = (void **) &disp->GetConvolutionParameterfv;
2871         snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameterfv", symbol_prefix);
2872         *procp = dlsym(handle, symboln);
2873     }
2874
2875
2876     if(!disp->GetConvolutionParameterfv) {
2877         void ** procp = (void **) &disp->GetConvolutionParameterfv;
2878         snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameterfvEXT", symbol_prefix);
2879         *procp = dlsym(handle, symboln);
2880     }
2881
2882
2883     if(!disp->GetConvolutionParameteriv) {
2884         void ** procp = (void **) &disp->GetConvolutionParameteriv;
2885         snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameteriv", symbol_prefix);
2886         *procp = dlsym(handle, symboln);
2887     }
2888
2889
2890     if(!disp->GetConvolutionParameteriv) {
2891         void ** procp = (void **) &disp->GetConvolutionParameteriv;
2892         snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameterivEXT", symbol_prefix);
2893         *procp = dlsym(handle, symboln);
2894     }
2895
2896
2897     if(!disp->GetSeparableFilter) {
2898         void ** procp = (void **) &disp->GetSeparableFilter;
2899         snprintf(symboln, sizeof(symboln), "%sGetSeparableFilter", symbol_prefix);
2900         *procp = dlsym(handle, symboln);
2901     }
2902
2903
2904     if(!disp->GetSeparableFilter) {
2905         void ** procp = (void **) &disp->GetSeparableFilter;
2906         snprintf(symboln, sizeof(symboln), "%sGetSeparableFilterEXT", symbol_prefix);
2907         *procp = dlsym(handle, symboln);
2908     }
2909
2910
2911     if(!disp->SeparableFilter2D) {
2912         void ** procp = (void **) &disp->SeparableFilter2D;
2913         snprintf(symboln, sizeof(symboln), "%sSeparableFilter2D", symbol_prefix);
2914         *procp = dlsym(handle, symboln);
2915     }
2916
2917
2918     if(!disp->SeparableFilter2D) {
2919         void ** procp = (void **) &disp->SeparableFilter2D;
2920         snprintf(symboln, sizeof(symboln), "%sSeparableFilter2DEXT", symbol_prefix);
2921         *procp = dlsym(handle, symboln);
2922     }
2923
2924
2925     if(!disp->GetHistogram) {
2926         void ** procp = (void **) &disp->GetHistogram;
2927         snprintf(symboln, sizeof(symboln), "%sGetHistogram", symbol_prefix);
2928         *procp = dlsym(handle, symboln);
2929     }
2930
2931
2932     if(!disp->GetHistogram) {
2933         void ** procp = (void **) &disp->GetHistogram;
2934         snprintf(symboln, sizeof(symboln), "%sGetHistogramEXT", symbol_prefix);
2935         *procp = dlsym(handle, symboln);
2936     }
2937
2938
2939     if(!disp->GetHistogramParameterfv) {
2940         void ** procp = (void **) &disp->GetHistogramParameterfv;
2941         snprintf(symboln, sizeof(symboln), "%sGetHistogramParameterfv", symbol_prefix);
2942         *procp = dlsym(handle, symboln);
2943     }
2944
2945
2946     if(!disp->GetHistogramParameterfv) {
2947         void ** procp = (void **) &disp->GetHistogramParameterfv;
2948         snprintf(symboln, sizeof(symboln), "%sGetHistogramParameterfvEXT", symbol_prefix);
2949         *procp = dlsym(handle, symboln);
2950     }
2951
2952
2953     if(!disp->GetHistogramParameteriv) {
2954         void ** procp = (void **) &disp->GetHistogramParameteriv;
2955         snprintf(symboln, sizeof(symboln), "%sGetHistogramParameteriv", symbol_prefix);
2956         *procp = dlsym(handle, symboln);
2957     }
2958
2959
2960     if(!disp->GetHistogramParameteriv) {
2961         void ** procp = (void **) &disp->GetHistogramParameteriv;
2962         snprintf(symboln, sizeof(symboln), "%sGetHistogramParameterivEXT", symbol_prefix);
2963         *procp = dlsym(handle, symboln);
2964     }
2965
2966
2967     if(!disp->GetMinmax) {
2968         void ** procp = (void **) &disp->GetMinmax;
2969         snprintf(symboln, sizeof(symboln), "%sGetMinmax", symbol_prefix);
2970         *procp = dlsym(handle, symboln);
2971     }
2972
2973
2974     if(!disp->GetMinmax) {
2975         void ** procp = (void **) &disp->GetMinmax;
2976         snprintf(symboln, sizeof(symboln), "%sGetMinmaxEXT", symbol_prefix);
2977         *procp = dlsym(handle, symboln);
2978     }
2979
2980
2981     if(!disp->GetMinmaxParameterfv) {
2982         void ** procp = (void **) &disp->GetMinmaxParameterfv;
2983         snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameterfv", symbol_prefix);
2984         *procp = dlsym(handle, symboln);
2985     }
2986
2987
2988     if(!disp->GetMinmaxParameterfv) {
2989         void ** procp = (void **) &disp->GetMinmaxParameterfv;
2990         snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameterfvEXT", symbol_prefix);
2991         *procp = dlsym(handle, symboln);
2992     }
2993
2994
2995     if(!disp->GetMinmaxParameteriv) {
2996         void ** procp = (void **) &disp->GetMinmaxParameteriv;
2997         snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameteriv", symbol_prefix);
2998         *procp = dlsym(handle, symboln);
2999     }
3000
3001
3002     if(!disp->GetMinmaxParameteriv) {
3003         void ** procp = (void **) &disp->GetMinmaxParameteriv;
3004         snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameterivEXT", symbol_prefix);
3005         *procp = dlsym(handle, symboln);
3006     }
3007
3008
3009     if(!disp->Histogram) {
3010         void ** procp = (void **) &disp->Histogram;
3011         snprintf(symboln, sizeof(symboln), "%sHistogram", symbol_prefix);
3012         *procp = dlsym(handle, symboln);
3013     }
3014
3015
3016     if(!disp->Histogram) {
3017         void ** procp = (void **) &disp->Histogram;
3018         snprintf(symboln, sizeof(symboln), "%sHistogramEXT", symbol_prefix);
3019         *procp = dlsym(handle, symboln);
3020     }
3021
3022
3023     if(!disp->Minmax) {
3024         void ** procp = (void **) &disp->Minmax;
3025         snprintf(symboln, sizeof(symboln), "%sMinmax", symbol_prefix);
3026         *procp = dlsym(handle, symboln);
3027     }
3028
3029
3030     if(!disp->Minmax) {
3031         void ** procp = (void **) &disp->Minmax;
3032         snprintf(symboln, sizeof(symboln), "%sMinmaxEXT", symbol_prefix);
3033         *procp = dlsym(handle, symboln);
3034     }
3035
3036
3037     if(!disp->ResetHistogram) {
3038         void ** procp = (void **) &disp->ResetHistogram;
3039         snprintf(symboln, sizeof(symboln), "%sResetHistogram", symbol_prefix);
3040         *procp = dlsym(handle, symboln);
3041     }
3042
3043
3044     if(!disp->ResetHistogram) {
3045         void ** procp = (void **) &disp->ResetHistogram;
3046         snprintf(symboln, sizeof(symboln), "%sResetHistogramEXT", symbol_prefix);
3047         *procp = dlsym(handle, symboln);
3048     }
3049
3050
3051     if(!disp->ResetMinmax) {
3052         void ** procp = (void **) &disp->ResetMinmax;
3053         snprintf(symboln, sizeof(symboln), "%sResetMinmax", symbol_prefix);
3054         *procp = dlsym(handle, symboln);
3055     }
3056
3057
3058     if(!disp->ResetMinmax) {
3059         void ** procp = (void **) &disp->ResetMinmax;
3060         snprintf(symboln, sizeof(symboln), "%sResetMinmaxEXT", symbol_prefix);
3061         *procp = dlsym(handle, symboln);
3062     }
3063
3064
3065     if(!disp->TexImage3D) {
3066         void ** procp = (void **) &disp->TexImage3D;
3067         snprintf(symboln, sizeof(symboln), "%sTexImage3D", symbol_prefix);
3068         *procp = dlsym(handle, symboln);
3069     }
3070
3071
3072     if(!disp->TexImage3D) {
3073         void ** procp = (void **) &disp->TexImage3D;
3074         snprintf(symboln, sizeof(symboln), "%sTexImage3DEXT", symbol_prefix);
3075         *procp = dlsym(handle, symboln);
3076     }
3077
3078
3079     if(!disp->TexSubImage3D) {
3080         void ** procp = (void **) &disp->TexSubImage3D;
3081         snprintf(symboln, sizeof(symboln), "%sTexSubImage3D", symbol_prefix);
3082         *procp = dlsym(handle, symboln);
3083     }
3084
3085
3086     if(!disp->TexSubImage3D) {
3087         void ** procp = (void **) &disp->TexSubImage3D;
3088         snprintf(symboln, sizeof(symboln), "%sTexSubImage3DEXT", symbol_prefix);
3089         *procp = dlsym(handle, symboln);
3090     }
3091
3092
3093     if(!disp->CopyTexSubImage3D) {
3094         void ** procp = (void **) &disp->CopyTexSubImage3D;
3095         snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage3D", symbol_prefix);
3096         *procp = dlsym(handle, symboln);
3097     }
3098
3099
3100     if(!disp->CopyTexSubImage3D) {
3101         void ** procp = (void **) &disp->CopyTexSubImage3D;
3102         snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage3DEXT", symbol_prefix);
3103         *procp = dlsym(handle, symboln);
3104     }
3105
3106
3107     if(!disp->ActiveTextureARB) {
3108         void ** procp = (void **) &disp->ActiveTextureARB;
3109         snprintf(symboln, sizeof(symboln), "%sActiveTexture", symbol_prefix);
3110         *procp = dlsym(handle, symboln);
3111     }
3112
3113
3114     if(!disp->ActiveTextureARB) {
3115         void ** procp = (void **) &disp->ActiveTextureARB;
3116         snprintf(symboln, sizeof(symboln), "%sActiveTextureARB", symbol_prefix);
3117         *procp = dlsym(handle, symboln);
3118     }
3119
3120
3121     if(!disp->ClientActiveTextureARB) {
3122         void ** procp = (void **) &disp->ClientActiveTextureARB;
3123         snprintf(symboln, sizeof(symboln), "%sClientActiveTexture", symbol_prefix);
3124         *procp = dlsym(handle, symboln);
3125     }
3126
3127
3128     if(!disp->ClientActiveTextureARB) {
3129         void ** procp = (void **) &disp->ClientActiveTextureARB;
3130         snprintf(symboln, sizeof(symboln), "%sClientActiveTextureARB", symbol_prefix);
3131         *procp = dlsym(handle, symboln);
3132     }
3133
3134
3135     if(!disp->MultiTexCoord1dARB) {
3136         void ** procp = (void **) &disp->MultiTexCoord1dARB;
3137         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1d", symbol_prefix);
3138         *procp = dlsym(handle, symboln);
3139     }
3140
3141
3142     if(!disp->MultiTexCoord1dARB) {
3143         void ** procp = (void **) &disp->MultiTexCoord1dARB;
3144         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1dARB", symbol_prefix);
3145         *procp = dlsym(handle, symboln);
3146     }
3147
3148
3149     if(!disp->MultiTexCoord1dvARB) {
3150         void ** procp = (void **) &disp->MultiTexCoord1dvARB;
3151         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1dv", symbol_prefix);
3152         *procp = dlsym(handle, symboln);
3153     }
3154
3155
3156     if(!disp->MultiTexCoord1dvARB) {
3157         void ** procp = (void **) &disp->MultiTexCoord1dvARB;
3158         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1dvARB", symbol_prefix);
3159         *procp = dlsym(handle, symboln);
3160     }
3161
3162
3163     if(!disp->MultiTexCoord1fARB) {
3164         void ** procp = (void **) &disp->MultiTexCoord1fARB;
3165         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1f", symbol_prefix);
3166         *procp = dlsym(handle, symboln);
3167     }
3168
3169
3170     if(!disp->MultiTexCoord1fARB) {
3171         void ** procp = (void **) &disp->MultiTexCoord1fARB;
3172         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1fARB", symbol_prefix);
3173         *procp = dlsym(handle, symboln);
3174     }
3175
3176
3177     if(!disp->MultiTexCoord1fvARB) {
3178         void ** procp = (void **) &disp->MultiTexCoord1fvARB;
3179         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1fv", symbol_prefix);
3180         *procp = dlsym(handle, symboln);
3181     }
3182
3183
3184     if(!disp->MultiTexCoord1fvARB) {
3185         void ** procp = (void **) &disp->MultiTexCoord1fvARB;
3186         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1fvARB", symbol_prefix);
3187         *procp = dlsym(handle, symboln);
3188     }
3189
3190
3191     if(!disp->MultiTexCoord1iARB) {
3192         void ** procp = (void **) &disp->MultiTexCoord1iARB;
3193         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1i", symbol_prefix);
3194         *procp = dlsym(handle, symboln);
3195     }
3196
3197
3198     if(!disp->MultiTexCoord1iARB) {
3199         void ** procp = (void **) &disp->MultiTexCoord1iARB;
3200         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1iARB", symbol_prefix);
3201         *procp = dlsym(handle, symboln);
3202     }
3203
3204
3205     if(!disp->MultiTexCoord1ivARB) {
3206         void ** procp = (void **) &disp->MultiTexCoord1ivARB;
3207         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1iv", symbol_prefix);
3208         *procp = dlsym(handle, symboln);
3209     }
3210
3211
3212     if(!disp->MultiTexCoord1ivARB) {
3213         void ** procp = (void **) &disp->MultiTexCoord1ivARB;
3214         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1ivARB", symbol_prefix);
3215         *procp = dlsym(handle, symboln);
3216     }
3217
3218
3219     if(!disp->MultiTexCoord1sARB) {
3220         void ** procp = (void **) &disp->MultiTexCoord1sARB;
3221         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1s", symbol_prefix);
3222         *procp = dlsym(handle, symboln);
3223     }
3224
3225
3226     if(!disp->MultiTexCoord1sARB) {
3227         void ** procp = (void **) &disp->MultiTexCoord1sARB;
3228         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1sARB", symbol_prefix);
3229         *procp = dlsym(handle, symboln);
3230     }
3231
3232
3233     if(!disp->MultiTexCoord1svARB) {
3234         void ** procp = (void **) &disp->MultiTexCoord1svARB;
3235         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1sv", symbol_prefix);
3236         *procp = dlsym(handle, symboln);
3237     }
3238
3239
3240     if(!disp->MultiTexCoord1svARB) {
3241         void ** procp = (void **) &disp->MultiTexCoord1svARB;
3242         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1svARB", symbol_prefix);
3243         *procp = dlsym(handle, symboln);
3244     }
3245
3246
3247     if(!disp->MultiTexCoord2dARB) {
3248         void ** procp = (void **) &disp->MultiTexCoord2dARB;
3249         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2d", symbol_prefix);
3250         *procp = dlsym(handle, symboln);
3251     }
3252
3253
3254     if(!disp->MultiTexCoord2dARB) {
3255         void ** procp = (void **) &disp->MultiTexCoord2dARB;
3256         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2dARB", symbol_prefix);
3257         *procp = dlsym(handle, symboln);
3258     }
3259
3260
3261     if(!disp->MultiTexCoord2dvARB) {
3262         void ** procp = (void **) &disp->MultiTexCoord2dvARB;
3263         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2dv", symbol_prefix);
3264         *procp = dlsym(handle, symboln);
3265     }
3266
3267
3268     if(!disp->MultiTexCoord2dvARB) {
3269         void ** procp = (void **) &disp->MultiTexCoord2dvARB;
3270         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2dvARB", symbol_prefix);
3271         *procp = dlsym(handle, symboln);
3272     }
3273
3274
3275     if(!disp->MultiTexCoord2fARB) {
3276         void ** procp = (void **) &disp->MultiTexCoord2fARB;
3277         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2f", symbol_prefix);
3278         *procp = dlsym(handle, symboln);
3279     }
3280
3281
3282     if(!disp->MultiTexCoord2fARB) {
3283         void ** procp = (void **) &disp->MultiTexCoord2fARB;
3284         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2fARB", symbol_prefix);
3285         *procp = dlsym(handle, symboln);
3286     }
3287
3288
3289     if(!disp->MultiTexCoord2fvARB) {
3290         void ** procp = (void **) &disp->MultiTexCoord2fvARB;
3291         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2fv", symbol_prefix);
3292         *procp = dlsym(handle, symboln);
3293     }
3294
3295
3296     if(!disp->MultiTexCoord2fvARB) {
3297         void ** procp = (void **) &disp->MultiTexCoord2fvARB;
3298         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2fvARB", symbol_prefix);
3299         *procp = dlsym(handle, symboln);
3300     }
3301
3302
3303     if(!disp->MultiTexCoord2iARB) {
3304         void ** procp = (void **) &disp->MultiTexCoord2iARB;
3305         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2i", symbol_prefix);
3306         *procp = dlsym(handle, symboln);
3307     }
3308
3309
3310     if(!disp->MultiTexCoord2iARB) {
3311         void ** procp = (void **) &disp->MultiTexCoord2iARB;
3312         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2iARB", symbol_prefix);
3313         *procp = dlsym(handle, symboln);
3314     }
3315
3316
3317     if(!disp->MultiTexCoord2ivARB) {
3318         void ** procp = (void **) &disp->MultiTexCoord2ivARB;
3319         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2iv", symbol_prefix);
3320         *procp = dlsym(handle, symboln);
3321     }
3322
3323
3324     if(!disp->MultiTexCoord2ivARB) {
3325         void ** procp = (void **) &disp->MultiTexCoord2ivARB;
3326         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2ivARB", symbol_prefix);
3327         *procp = dlsym(handle, symboln);
3328     }
3329
3330
3331     if(!disp->MultiTexCoord2sARB) {
3332         void ** procp = (void **) &disp->MultiTexCoord2sARB;
3333         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2s", symbol_prefix);
3334         *procp = dlsym(handle, symboln);
3335     }
3336
3337
3338     if(!disp->MultiTexCoord2sARB) {
3339         void ** procp = (void **) &disp->MultiTexCoord2sARB;
3340         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2sARB", symbol_prefix);
3341         *procp = dlsym(handle, symboln);
3342     }
3343
3344
3345     if(!disp->MultiTexCoord2svARB) {
3346         void ** procp = (void **) &disp->MultiTexCoord2svARB;
3347         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2sv", symbol_prefix);
3348         *procp = dlsym(handle, symboln);
3349     }
3350
3351
3352     if(!disp->MultiTexCoord2svARB) {
3353         void ** procp = (void **) &disp->MultiTexCoord2svARB;
3354         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2svARB", symbol_prefix);
3355         *procp = dlsym(handle, symboln);
3356     }
3357
3358
3359     if(!disp->MultiTexCoord3dARB) {
3360         void ** procp = (void **) &disp->MultiTexCoord3dARB;
3361         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3d", symbol_prefix);
3362         *procp = dlsym(handle, symboln);
3363     }
3364
3365
3366     if(!disp->MultiTexCoord3dARB) {
3367         void ** procp = (void **) &disp->MultiTexCoord3dARB;
3368         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3dARB", symbol_prefix);
3369         *procp = dlsym(handle, symboln);
3370     }
3371
3372
3373     if(!disp->MultiTexCoord3dvARB) {
3374         void ** procp = (void **) &disp->MultiTexCoord3dvARB;
3375         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3dv", symbol_prefix);
3376         *procp = dlsym(handle, symboln);
3377     }
3378
3379
3380     if(!disp->MultiTexCoord3dvARB) {
3381         void ** procp = (void **) &disp->MultiTexCoord3dvARB;
3382         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3dvARB", symbol_prefix);
3383         *procp = dlsym(handle, symboln);
3384     }
3385
3386
3387     if(!disp->MultiTexCoord3fARB) {
3388         void ** procp = (void **) &disp->MultiTexCoord3fARB;
3389         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3f", symbol_prefix);
3390         *procp = dlsym(handle, symboln);
3391     }
3392
3393
3394     if(!disp->MultiTexCoord3fARB) {
3395         void ** procp = (void **) &disp->MultiTexCoord3fARB;
3396         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3fARB", symbol_prefix);
3397         *procp = dlsym(handle, symboln);
3398     }
3399
3400
3401     if(!disp->MultiTexCoord3fvARB) {
3402         void ** procp = (void **) &disp->MultiTexCoord3fvARB;
3403         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3fv", symbol_prefix);
3404         *procp = dlsym(handle, symboln);
3405     }
3406
3407
3408     if(!disp->MultiTexCoord3fvARB) {
3409         void ** procp = (void **) &disp->MultiTexCoord3fvARB;
3410         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3fvARB", symbol_prefix);
3411         *procp = dlsym(handle, symboln);
3412     }
3413
3414
3415     if(!disp->MultiTexCoord3iARB) {
3416         void ** procp = (void **) &disp->MultiTexCoord3iARB;
3417         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3i", symbol_prefix);
3418         *procp = dlsym(handle, symboln);
3419     }
3420
3421
3422     if(!disp->MultiTexCoord3iARB) {
3423         void ** procp = (void **) &disp->MultiTexCoord3iARB;
3424         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3iARB", symbol_prefix);
3425         *procp = dlsym(handle, symboln);
3426     }
3427
3428
3429     if(!disp->MultiTexCoord3ivARB) {
3430         void ** procp = (void **) &disp->MultiTexCoord3ivARB;
3431         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3iv", symbol_prefix);
3432         *procp = dlsym(handle, symboln);
3433     }
3434
3435
3436     if(!disp->MultiTexCoord3ivARB) {
3437         void ** procp = (void **) &disp->MultiTexCoord3ivARB;
3438         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3ivARB", symbol_prefix);
3439         *procp = dlsym(handle, symboln);
3440     }
3441
3442
3443     if(!disp->MultiTexCoord3sARB) {
3444         void ** procp = (void **) &disp->MultiTexCoord3sARB;
3445         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3s", symbol_prefix);
3446         *procp = dlsym(handle, symboln);
3447     }
3448
3449
3450     if(!disp->MultiTexCoord3sARB) {
3451         void ** procp = (void **) &disp->MultiTexCoord3sARB;
3452         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3sARB", symbol_prefix);
3453         *procp = dlsym(handle, symboln);
3454     }
3455
3456
3457     if(!disp->MultiTexCoord3svARB) {
3458         void ** procp = (void **) &disp->MultiTexCoord3svARB;
3459         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3sv", symbol_prefix);
3460         *procp = dlsym(handle, symboln);
3461     }
3462
3463
3464     if(!disp->MultiTexCoord3svARB) {
3465         void ** procp = (void **) &disp->MultiTexCoord3svARB;
3466         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3svARB", symbol_prefix);
3467         *procp = dlsym(handle, symboln);
3468     }
3469
3470
3471     if(!disp->MultiTexCoord4dARB) {
3472         void ** procp = (void **) &disp->MultiTexCoord4dARB;
3473         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4d", symbol_prefix);
3474         *procp = dlsym(handle, symboln);
3475     }
3476
3477
3478     if(!disp->MultiTexCoord4dARB) {
3479         void ** procp = (void **) &disp->MultiTexCoord4dARB;
3480         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4dARB", symbol_prefix);
3481         *procp = dlsym(handle, symboln);
3482     }
3483
3484
3485     if(!disp->MultiTexCoord4dvARB) {
3486         void ** procp = (void **) &disp->MultiTexCoord4dvARB;
3487         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4dv", symbol_prefix);
3488         *procp = dlsym(handle, symboln);
3489     }
3490
3491
3492     if(!disp->MultiTexCoord4dvARB) {
3493         void ** procp = (void **) &disp->MultiTexCoord4dvARB;
3494         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4dvARB", symbol_prefix);
3495         *procp = dlsym(handle, symboln);
3496     }
3497
3498
3499     if(!disp->MultiTexCoord4fARB) {
3500         void ** procp = (void **) &disp->MultiTexCoord4fARB;
3501         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4f", symbol_prefix);
3502         *procp = dlsym(handle, symboln);
3503     }
3504
3505
3506     if(!disp->MultiTexCoord4fARB) {
3507         void ** procp = (void **) &disp->MultiTexCoord4fARB;
3508         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4fARB", symbol_prefix);
3509         *procp = dlsym(handle, symboln);
3510     }
3511
3512
3513     if(!disp->MultiTexCoord4fvARB) {
3514         void ** procp = (void **) &disp->MultiTexCoord4fvARB;
3515         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4fv", symbol_prefix);
3516         *procp = dlsym(handle, symboln);
3517     }
3518
3519
3520     if(!disp->MultiTexCoord4fvARB) {
3521         void ** procp = (void **) &disp->MultiTexCoord4fvARB;
3522         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4fvARB", symbol_prefix);
3523         *procp = dlsym(handle, symboln);
3524     }
3525
3526
3527     if(!disp->MultiTexCoord4iARB) {
3528         void ** procp = (void **) &disp->MultiTexCoord4iARB;
3529         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4i", symbol_prefix);
3530         *procp = dlsym(handle, symboln);
3531     }
3532
3533
3534     if(!disp->MultiTexCoord4iARB) {
3535         void ** procp = (void **) &disp->MultiTexCoord4iARB;
3536         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4iARB", symbol_prefix);
3537         *procp = dlsym(handle, symboln);
3538     }
3539
3540
3541     if(!disp->MultiTexCoord4ivARB) {
3542         void ** procp = (void **) &disp->MultiTexCoord4ivARB;
3543         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4iv", symbol_prefix);
3544         *procp = dlsym(handle, symboln);
3545     }
3546
3547
3548     if(!disp->MultiTexCoord4ivARB) {
3549         void ** procp = (void **) &disp->MultiTexCoord4ivARB;
3550         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4ivARB", symbol_prefix);
3551         *procp = dlsym(handle, symboln);
3552     }
3553
3554
3555     if(!disp->MultiTexCoord4sARB) {
3556         void ** procp = (void **) &disp->MultiTexCoord4sARB;
3557         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4s", symbol_prefix);
3558         *procp = dlsym(handle, symboln);
3559     }
3560
3561
3562     if(!disp->MultiTexCoord4sARB) {
3563         void ** procp = (void **) &disp->MultiTexCoord4sARB;
3564         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4sARB", symbol_prefix);
3565         *procp = dlsym(handle, symboln);
3566     }
3567
3568
3569     if(!disp->MultiTexCoord4svARB) {
3570         void ** procp = (void **) &disp->MultiTexCoord4svARB;
3571         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4sv", symbol_prefix);
3572         *procp = dlsym(handle, symboln);
3573     }
3574
3575
3576     if(!disp->MultiTexCoord4svARB) {
3577         void ** procp = (void **) &disp->MultiTexCoord4svARB;
3578         snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4svARB", symbol_prefix);
3579         *procp = dlsym(handle, symboln);
3580     }
3581
3582
3583     if(!disp->AttachShader) {
3584         void ** procp = (void **) &disp->AttachShader;
3585         snprintf(symboln, sizeof(symboln), "%sAttachShader", symbol_prefix);
3586         *procp = dlsym(handle, symboln);
3587     }
3588
3589
3590     if(!disp->CreateProgram) {
3591         void ** procp = (void **) &disp->CreateProgram;
3592         snprintf(symboln, sizeof(symboln), "%sCreateProgram", symbol_prefix);
3593         *procp = dlsym(handle, symboln);
3594     }
3595
3596
3597     if(!disp->CreateShader) {
3598         void ** procp = (void **) &disp->CreateShader;
3599         snprintf(symboln, sizeof(symboln), "%sCreateShader", symbol_prefix);
3600         *procp = dlsym(handle, symboln);
3601     }
3602
3603
3604     if(!disp->DeleteProgram) {
3605         void ** procp = (void **) &disp->DeleteProgram;
3606         snprintf(symboln, sizeof(symboln), "%sDeleteProgram", symbol_prefix);
3607         *procp = dlsym(handle, symboln);
3608     }
3609
3610
3611     if(!disp->DeleteShader) {
3612         void ** procp = (void **) &disp->DeleteShader;
3613         snprintf(symboln, sizeof(symboln), "%sDeleteShader", symbol_prefix);
3614         *procp = dlsym(handle, symboln);
3615     }
3616
3617
3618     if(!disp->DetachShader) {
3619         void ** procp = (void **) &disp->DetachShader;
3620         snprintf(symboln, sizeof(symboln), "%sDetachShader", symbol_prefix);
3621         *procp = dlsym(handle, symboln);
3622     }
3623
3624
3625     if(!disp->GetAttachedShaders) {
3626         void ** procp = (void **) &disp->GetAttachedShaders;
3627         snprintf(symboln, sizeof(symboln), "%sGetAttachedShaders", symbol_prefix);
3628         *procp = dlsym(handle, symboln);
3629     }
3630
3631
3632     if(!disp->GetProgramInfoLog) {
3633         void ** procp = (void **) &disp->GetProgramInfoLog;
3634         snprintf(symboln, sizeof(symboln), "%sGetProgramInfoLog", symbol_prefix);
3635         *procp = dlsym(handle, symboln);
3636     }
3637
3638
3639     if(!disp->GetProgramiv) {
3640         void ** procp = (void **) &disp->GetProgramiv;
3641         snprintf(symboln, sizeof(symboln), "%sGetProgramiv", symbol_prefix);
3642         *procp = dlsym(handle, symboln);
3643     }
3644
3645
3646     if(!disp->GetShaderInfoLog) {
3647         void ** procp = (void **) &disp->GetShaderInfoLog;
3648         snprintf(symboln, sizeof(symboln), "%sGetShaderInfoLog", symbol_prefix);
3649         *procp = dlsym(handle, symboln);
3650     }
3651
3652
3653     if(!disp->GetShaderiv) {
3654         void ** procp = (void **) &disp->GetShaderiv;
3655         snprintf(symboln, sizeof(symboln), "%sGetShaderiv", symbol_prefix);
3656         *procp = dlsym(handle, symboln);
3657     }
3658
3659
3660     if(!disp->IsProgram) {
3661         void ** procp = (void **) &disp->IsProgram;
3662         snprintf(symboln, sizeof(symboln), "%sIsProgram", symbol_prefix);
3663         *procp = dlsym(handle, symboln);
3664     }
3665
3666
3667     if(!disp->IsShader) {
3668         void ** procp = (void **) &disp->IsShader;
3669         snprintf(symboln, sizeof(symboln), "%sIsShader", symbol_prefix);
3670         *procp = dlsym(handle, symboln);
3671     }
3672
3673
3674     if(!disp->StencilFuncSeparate) {
3675         void ** procp = (void **) &disp->StencilFuncSeparate;
3676         snprintf(symboln, sizeof(symboln), "%sStencilFuncSeparate", symbol_prefix);
3677         *procp = dlsym(handle, symboln);
3678     }
3679
3680
3681     if(!disp->StencilMaskSeparate) {
3682         void ** procp = (void **) &disp->StencilMaskSeparate;
3683         snprintf(symboln, sizeof(symboln), "%sStencilMaskSeparate", symbol_prefix);
3684         *procp = dlsym(handle, symboln);
3685     }
3686
3687
3688     if(!disp->StencilOpSeparate) {
3689         void ** procp = (void **) &disp->StencilOpSeparate;
3690         snprintf(symboln, sizeof(symboln), "%sStencilOpSeparate", symbol_prefix);
3691         *procp = dlsym(handle, symboln);
3692     }
3693
3694
3695     if(!disp->StencilOpSeparate) {
3696         void ** procp = (void **) &disp->StencilOpSeparate;
3697         snprintf(symboln, sizeof(symboln), "%sStencilOpSeparateATI", symbol_prefix);
3698         *procp = dlsym(handle, symboln);
3699     }
3700
3701
3702     if(!disp->UniformMatrix2x3fv) {
3703         void ** procp = (void **) &disp->UniformMatrix2x3fv;
3704         snprintf(symboln, sizeof(symboln), "%sUniformMatrix2x3fv", symbol_prefix);
3705         *procp = dlsym(handle, symboln);
3706     }
3707
3708
3709     if(!disp->UniformMatrix2x4fv) {
3710         void ** procp = (void **) &disp->UniformMatrix2x4fv;
3711         snprintf(symboln, sizeof(symboln), "%sUniformMatrix2x4fv", symbol_prefix);
3712         *procp = dlsym(handle, symboln);
3713     }
3714
3715
3716     if(!disp->UniformMatrix3x2fv) {
3717         void ** procp = (void **) &disp->UniformMatrix3x2fv;
3718         snprintf(symboln, sizeof(symboln), "%sUniformMatrix3x2fv", symbol_prefix);
3719         *procp = dlsym(handle, symboln);
3720     }
3721
3722
3723     if(!disp->UniformMatrix3x4fv) {
3724         void ** procp = (void **) &disp->UniformMatrix3x4fv;
3725         snprintf(symboln, sizeof(symboln), "%sUniformMatrix3x4fv", symbol_prefix);
3726         *procp = dlsym(handle, symboln);
3727     }
3728
3729
3730     if(!disp->UniformMatrix4x2fv) {
3731         void ** procp = (void **) &disp->UniformMatrix4x2fv;
3732         snprintf(symboln, sizeof(symboln), "%sUniformMatrix4x2fv", symbol_prefix);
3733         *procp = dlsym(handle, symboln);
3734     }
3735
3736
3737     if(!disp->UniformMatrix4x3fv) {
3738         void ** procp = (void **) &disp->UniformMatrix4x3fv;
3739         snprintf(symboln, sizeof(symboln), "%sUniformMatrix4x3fv", symbol_prefix);
3740         *procp = dlsym(handle, symboln);
3741     }
3742
3743
3744     if(!disp->ClampColor) {
3745         void ** procp = (void **) &disp->ClampColor;
3746         snprintf(symboln, sizeof(symboln), "%sClampColor", symbol_prefix);
3747         *procp = dlsym(handle, symboln);
3748     }
3749
3750
3751     if(!disp->ClearBufferfi) {
3752         void ** procp = (void **) &disp->ClearBufferfi;
3753         snprintf(symboln, sizeof(symboln), "%sClearBufferfi", symbol_prefix);
3754         *procp = dlsym(handle, symboln);
3755     }
3756
3757
3758     if(!disp->ClearBufferfv) {
3759         void ** procp = (void **) &disp->ClearBufferfv;
3760         snprintf(symboln, sizeof(symboln), "%sClearBufferfv", symbol_prefix);
3761         *procp = dlsym(handle, symboln);
3762     }
3763
3764
3765     if(!disp->ClearBufferiv) {
3766         void ** procp = (void **) &disp->ClearBufferiv;
3767         snprintf(symboln, sizeof(symboln), "%sClearBufferiv", symbol_prefix);
3768         *procp = dlsym(handle, symboln);
3769     }
3770
3771
3772     if(!disp->ClearBufferuiv) {
3773         void ** procp = (void **) &disp->ClearBufferuiv;
3774         snprintf(symboln, sizeof(symboln), "%sClearBufferuiv", symbol_prefix);
3775         *procp = dlsym(handle, symboln);
3776     }
3777
3778
3779     if(!disp->GetStringi) {
3780         void ** procp = (void **) &disp->GetStringi;
3781         snprintf(symboln, sizeof(symboln), "%sGetStringi", symbol_prefix);
3782         *procp = dlsym(handle, symboln);
3783     }
3784
3785
3786     if(!disp->TexBuffer) {
3787         void ** procp = (void **) &disp->TexBuffer;
3788         snprintf(symboln, sizeof(symboln), "%sTexBuffer", symbol_prefix);
3789         *procp = dlsym(handle, symboln);
3790     }
3791
3792
3793     if(!disp->FramebufferTexture) {
3794         void ** procp = (void **) &disp->FramebufferTexture;
3795         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture", symbol_prefix);
3796         *procp = dlsym(handle, symboln);
3797     }
3798
3799
3800     if(!disp->GetBufferParameteri64v) {
3801         void ** procp = (void **) &disp->GetBufferParameteri64v;
3802         snprintf(symboln, sizeof(symboln), "%sGetBufferParameteri64v", symbol_prefix);
3803         *procp = dlsym(handle, symboln);
3804     }
3805
3806
3807     if(!disp->GetInteger64i_v) {
3808         void ** procp = (void **) &disp->GetInteger64i_v;
3809         snprintf(symboln, sizeof(symboln), "%sGetInteger64i_v", symbol_prefix);
3810         *procp = dlsym(handle, symboln);
3811     }
3812
3813
3814     if(!disp->VertexAttribDivisor) {
3815         void ** procp = (void **) &disp->VertexAttribDivisor;
3816         snprintf(symboln, sizeof(symboln), "%sVertexAttribDivisor", symbol_prefix);
3817         *procp = dlsym(handle, symboln);
3818     }
3819
3820
3821     if(!disp->LoadTransposeMatrixdARB) {
3822         void ** procp = (void **) &disp->LoadTransposeMatrixdARB;
3823         snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixd", symbol_prefix);
3824         *procp = dlsym(handle, symboln);
3825     }
3826
3827
3828     if(!disp->LoadTransposeMatrixdARB) {
3829         void ** procp = (void **) &disp->LoadTransposeMatrixdARB;
3830         snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixdARB", symbol_prefix);
3831         *procp = dlsym(handle, symboln);
3832     }
3833
3834
3835     if(!disp->LoadTransposeMatrixfARB) {
3836         void ** procp = (void **) &disp->LoadTransposeMatrixfARB;
3837         snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixf", symbol_prefix);
3838         *procp = dlsym(handle, symboln);
3839     }
3840
3841
3842     if(!disp->LoadTransposeMatrixfARB) {
3843         void ** procp = (void **) &disp->LoadTransposeMatrixfARB;
3844         snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixfARB", symbol_prefix);
3845         *procp = dlsym(handle, symboln);
3846     }
3847
3848
3849     if(!disp->MultTransposeMatrixdARB) {
3850         void ** procp = (void **) &disp->MultTransposeMatrixdARB;
3851         snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixd", symbol_prefix);
3852         *procp = dlsym(handle, symboln);
3853     }
3854
3855
3856     if(!disp->MultTransposeMatrixdARB) {
3857         void ** procp = (void **) &disp->MultTransposeMatrixdARB;
3858         snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixdARB", symbol_prefix);
3859         *procp = dlsym(handle, symboln);
3860     }
3861
3862
3863     if(!disp->MultTransposeMatrixfARB) {
3864         void ** procp = (void **) &disp->MultTransposeMatrixfARB;
3865         snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixf", symbol_prefix);
3866         *procp = dlsym(handle, symboln);
3867     }
3868
3869
3870     if(!disp->MultTransposeMatrixfARB) {
3871         void ** procp = (void **) &disp->MultTransposeMatrixfARB;
3872         snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixfARB", symbol_prefix);
3873         *procp = dlsym(handle, symboln);
3874     }
3875
3876
3877     if(!disp->SampleCoverageARB) {
3878         void ** procp = (void **) &disp->SampleCoverageARB;
3879         snprintf(symboln, sizeof(symboln), "%sSampleCoverage", symbol_prefix);
3880         *procp = dlsym(handle, symboln);
3881     }
3882
3883
3884     if(!disp->SampleCoverageARB) {
3885         void ** procp = (void **) &disp->SampleCoverageARB;
3886         snprintf(symboln, sizeof(symboln), "%sSampleCoverageARB", symbol_prefix);
3887         *procp = dlsym(handle, symboln);
3888     }
3889
3890
3891     if(!disp->CompressedTexImage1DARB) {
3892         void ** procp = (void **) &disp->CompressedTexImage1DARB;
3893         snprintf(symboln, sizeof(symboln), "%sCompressedTexImage1D", symbol_prefix);
3894         *procp = dlsym(handle, symboln);
3895     }
3896
3897
3898     if(!disp->CompressedTexImage1DARB) {
3899         void ** procp = (void **) &disp->CompressedTexImage1DARB;
3900         snprintf(symboln, sizeof(symboln), "%sCompressedTexImage1DARB", symbol_prefix);
3901         *procp = dlsym(handle, symboln);
3902     }
3903
3904
3905     if(!disp->CompressedTexImage2DARB) {
3906         void ** procp = (void **) &disp->CompressedTexImage2DARB;
3907         snprintf(symboln, sizeof(symboln), "%sCompressedTexImage2D", symbol_prefix);
3908         *procp = dlsym(handle, symboln);
3909     }
3910
3911
3912     if(!disp->CompressedTexImage2DARB) {
3913         void ** procp = (void **) &disp->CompressedTexImage2DARB;
3914         snprintf(symboln, sizeof(symboln), "%sCompressedTexImage2DARB", symbol_prefix);
3915         *procp = dlsym(handle, symboln);
3916     }
3917
3918
3919     if(!disp->CompressedTexImage3DARB) {
3920         void ** procp = (void **) &disp->CompressedTexImage3DARB;
3921         snprintf(symboln, sizeof(symboln), "%sCompressedTexImage3D", symbol_prefix);
3922         *procp = dlsym(handle, symboln);
3923     }
3924
3925
3926     if(!disp->CompressedTexImage3DARB) {
3927         void ** procp = (void **) &disp->CompressedTexImage3DARB;
3928         snprintf(symboln, sizeof(symboln), "%sCompressedTexImage3DARB", symbol_prefix);
3929         *procp = dlsym(handle, symboln);
3930     }
3931
3932
3933     if(!disp->CompressedTexSubImage1DARB) {
3934         void ** procp = (void **) &disp->CompressedTexSubImage1DARB;
3935         snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage1D", symbol_prefix);
3936         *procp = dlsym(handle, symboln);
3937     }
3938
3939
3940     if(!disp->CompressedTexSubImage1DARB) {
3941         void ** procp = (void **) &disp->CompressedTexSubImage1DARB;
3942         snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage1DARB", symbol_prefix);
3943         *procp = dlsym(handle, symboln);
3944     }
3945
3946
3947     if(!disp->CompressedTexSubImage2DARB) {
3948         void ** procp = (void **) &disp->CompressedTexSubImage2DARB;
3949         snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage2D", symbol_prefix);
3950         *procp = dlsym(handle, symboln);
3951     }
3952
3953
3954     if(!disp->CompressedTexSubImage2DARB) {
3955         void ** procp = (void **) &disp->CompressedTexSubImage2DARB;
3956         snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage2DARB", symbol_prefix);
3957         *procp = dlsym(handle, symboln);
3958     }
3959
3960
3961     if(!disp->CompressedTexSubImage3DARB) {
3962         void ** procp = (void **) &disp->CompressedTexSubImage3DARB;
3963         snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage3D", symbol_prefix);
3964         *procp = dlsym(handle, symboln);
3965     }
3966
3967
3968     if(!disp->CompressedTexSubImage3DARB) {
3969         void ** procp = (void **) &disp->CompressedTexSubImage3DARB;
3970         snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage3DARB", symbol_prefix);
3971         *procp = dlsym(handle, symboln);
3972     }
3973
3974
3975     if(!disp->GetCompressedTexImageARB) {
3976         void ** procp = (void **) &disp->GetCompressedTexImageARB;
3977         snprintf(symboln, sizeof(symboln), "%sGetCompressedTexImage", symbol_prefix);
3978         *procp = dlsym(handle, symboln);
3979     }
3980
3981
3982     if(!disp->GetCompressedTexImageARB) {
3983         void ** procp = (void **) &disp->GetCompressedTexImageARB;
3984         snprintf(symboln, sizeof(symboln), "%sGetCompressedTexImageARB", symbol_prefix);
3985         *procp = dlsym(handle, symboln);
3986     }
3987
3988
3989     if(!disp->DisableVertexAttribArrayARB) {
3990         void ** procp = (void **) &disp->DisableVertexAttribArrayARB;
3991         snprintf(symboln, sizeof(symboln), "%sDisableVertexAttribArray", symbol_prefix);
3992         *procp = dlsym(handle, symboln);
3993     }
3994
3995
3996     if(!disp->DisableVertexAttribArrayARB) {
3997         void ** procp = (void **) &disp->DisableVertexAttribArrayARB;
3998         snprintf(symboln, sizeof(symboln), "%sDisableVertexAttribArrayARB", symbol_prefix);
3999         *procp = dlsym(handle, symboln);
4000     }
4001
4002
4003     if(!disp->EnableVertexAttribArrayARB) {
4004         void ** procp = (void **) &disp->EnableVertexAttribArrayARB;
4005         snprintf(symboln, sizeof(symboln), "%sEnableVertexAttribArray", symbol_prefix);
4006         *procp = dlsym(handle, symboln);
4007     }
4008
4009
4010     if(!disp->EnableVertexAttribArrayARB) {
4011         void ** procp = (void **) &disp->EnableVertexAttribArrayARB;
4012         snprintf(symboln, sizeof(symboln), "%sEnableVertexAttribArrayARB", symbol_prefix);
4013         *procp = dlsym(handle, symboln);
4014     }
4015
4016
4017     if(!disp->GetProgramEnvParameterdvARB) {
4018         void ** procp = (void **) &disp->GetProgramEnvParameterdvARB;
4019         snprintf(symboln, sizeof(symboln), "%sGetProgramEnvParameterdvARB", symbol_prefix);
4020         *procp = dlsym(handle, symboln);
4021     }
4022
4023
4024     if(!disp->GetProgramEnvParameterfvARB) {
4025         void ** procp = (void **) &disp->GetProgramEnvParameterfvARB;
4026         snprintf(symboln, sizeof(symboln), "%sGetProgramEnvParameterfvARB", symbol_prefix);
4027         *procp = dlsym(handle, symboln);
4028     }
4029
4030
4031     if(!disp->GetProgramLocalParameterdvARB) {
4032         void ** procp = (void **) &disp->GetProgramLocalParameterdvARB;
4033         snprintf(symboln, sizeof(symboln), "%sGetProgramLocalParameterdvARB", symbol_prefix);
4034         *procp = dlsym(handle, symboln);
4035     }
4036
4037
4038     if(!disp->GetProgramLocalParameterfvARB) {
4039         void ** procp = (void **) &disp->GetProgramLocalParameterfvARB;
4040         snprintf(symboln, sizeof(symboln), "%sGetProgramLocalParameterfvARB", symbol_prefix);
4041         *procp = dlsym(handle, symboln);
4042     }
4043
4044
4045     if(!disp->GetProgramStringARB) {
4046         void ** procp = (void **) &disp->GetProgramStringARB;
4047         snprintf(symboln, sizeof(symboln), "%sGetProgramStringARB", symbol_prefix);
4048         *procp = dlsym(handle, symboln);
4049     }
4050
4051
4052     if(!disp->GetProgramivARB) {
4053         void ** procp = (void **) &disp->GetProgramivARB;
4054         snprintf(symboln, sizeof(symboln), "%sGetProgramivARB", symbol_prefix);
4055         *procp = dlsym(handle, symboln);
4056     }
4057
4058
4059     if(!disp->GetVertexAttribdvARB) {
4060         void ** procp = (void **) &disp->GetVertexAttribdvARB;
4061         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribdv", symbol_prefix);
4062         *procp = dlsym(handle, symboln);
4063     }
4064
4065
4066     if(!disp->GetVertexAttribdvARB) {
4067         void ** procp = (void **) &disp->GetVertexAttribdvARB;
4068         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribdvARB", symbol_prefix);
4069         *procp = dlsym(handle, symboln);
4070     }
4071
4072
4073     if(!disp->GetVertexAttribfvARB) {
4074         void ** procp = (void **) &disp->GetVertexAttribfvARB;
4075         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribfv", symbol_prefix);
4076         *procp = dlsym(handle, symboln);
4077     }
4078
4079
4080     if(!disp->GetVertexAttribfvARB) {
4081         void ** procp = (void **) &disp->GetVertexAttribfvARB;
4082         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribfvARB", symbol_prefix);
4083         *procp = dlsym(handle, symboln);
4084     }
4085
4086
4087     if(!disp->GetVertexAttribivARB) {
4088         void ** procp = (void **) &disp->GetVertexAttribivARB;
4089         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribiv", symbol_prefix);
4090         *procp = dlsym(handle, symboln);
4091     }
4092
4093
4094     if(!disp->GetVertexAttribivARB) {
4095         void ** procp = (void **) &disp->GetVertexAttribivARB;
4096         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribivARB", symbol_prefix);
4097         *procp = dlsym(handle, symboln);
4098     }
4099
4100
4101     if(!disp->ProgramEnvParameter4dARB) {
4102         void ** procp = (void **) &disp->ProgramEnvParameter4dARB;
4103         snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4dARB", symbol_prefix);
4104         *procp = dlsym(handle, symboln);
4105     }
4106
4107
4108     if(!disp->ProgramEnvParameter4dARB) {
4109         void ** procp = (void **) &disp->ProgramEnvParameter4dARB;
4110         snprintf(symboln, sizeof(symboln), "%sProgramParameter4dNV", symbol_prefix);
4111         *procp = dlsym(handle, symboln);
4112     }
4113
4114
4115     if(!disp->ProgramEnvParameter4dvARB) {
4116         void ** procp = (void **) &disp->ProgramEnvParameter4dvARB;
4117         snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4dvARB", symbol_prefix);
4118         *procp = dlsym(handle, symboln);
4119     }
4120
4121
4122     if(!disp->ProgramEnvParameter4dvARB) {
4123         void ** procp = (void **) &disp->ProgramEnvParameter4dvARB;
4124         snprintf(symboln, sizeof(symboln), "%sProgramParameter4dvNV", symbol_prefix);
4125         *procp = dlsym(handle, symboln);
4126     }
4127
4128
4129     if(!disp->ProgramEnvParameter4fARB) {
4130         void ** procp = (void **) &disp->ProgramEnvParameter4fARB;
4131         snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4fARB", symbol_prefix);
4132         *procp = dlsym(handle, symboln);
4133     }
4134
4135
4136     if(!disp->ProgramEnvParameter4fARB) {
4137         void ** procp = (void **) &disp->ProgramEnvParameter4fARB;
4138         snprintf(symboln, sizeof(symboln), "%sProgramParameter4fNV", symbol_prefix);
4139         *procp = dlsym(handle, symboln);
4140     }
4141
4142
4143     if(!disp->ProgramEnvParameter4fvARB) {
4144         void ** procp = (void **) &disp->ProgramEnvParameter4fvARB;
4145         snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4fvARB", symbol_prefix);
4146         *procp = dlsym(handle, symboln);
4147     }
4148
4149
4150     if(!disp->ProgramEnvParameter4fvARB) {
4151         void ** procp = (void **) &disp->ProgramEnvParameter4fvARB;
4152         snprintf(symboln, sizeof(symboln), "%sProgramParameter4fvNV", symbol_prefix);
4153         *procp = dlsym(handle, symboln);
4154     }
4155
4156
4157     if(!disp->ProgramLocalParameter4dARB) {
4158         void ** procp = (void **) &disp->ProgramLocalParameter4dARB;
4159         snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4dARB", symbol_prefix);
4160         *procp = dlsym(handle, symboln);
4161     }
4162
4163
4164     if(!disp->ProgramLocalParameter4dvARB) {
4165         void ** procp = (void **) &disp->ProgramLocalParameter4dvARB;
4166         snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4dvARB", symbol_prefix);
4167         *procp = dlsym(handle, symboln);
4168     }
4169
4170
4171     if(!disp->ProgramLocalParameter4fARB) {
4172         void ** procp = (void **) &disp->ProgramLocalParameter4fARB;
4173         snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4fARB", symbol_prefix);
4174         *procp = dlsym(handle, symboln);
4175     }
4176
4177
4178     if(!disp->ProgramLocalParameter4fvARB) {
4179         void ** procp = (void **) &disp->ProgramLocalParameter4fvARB;
4180         snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4fvARB", symbol_prefix);
4181         *procp = dlsym(handle, symboln);
4182     }
4183
4184
4185     if(!disp->ProgramStringARB) {
4186         void ** procp = (void **) &disp->ProgramStringARB;
4187         snprintf(symboln, sizeof(symboln), "%sProgramStringARB", symbol_prefix);
4188         *procp = dlsym(handle, symboln);
4189     }
4190
4191
4192     if(!disp->VertexAttrib1dARB) {
4193         void ** procp = (void **) &disp->VertexAttrib1dARB;
4194         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1d", symbol_prefix);
4195         *procp = dlsym(handle, symboln);
4196     }
4197
4198
4199     if(!disp->VertexAttrib1dARB) {
4200         void ** procp = (void **) &disp->VertexAttrib1dARB;
4201         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dARB", symbol_prefix);
4202         *procp = dlsym(handle, symboln);
4203     }
4204
4205
4206     if(!disp->VertexAttrib1dvARB) {
4207         void ** procp = (void **) &disp->VertexAttrib1dvARB;
4208         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dv", symbol_prefix);
4209         *procp = dlsym(handle, symboln);
4210     }
4211
4212
4213     if(!disp->VertexAttrib1dvARB) {
4214         void ** procp = (void **) &disp->VertexAttrib1dvARB;
4215         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dvARB", symbol_prefix);
4216         *procp = dlsym(handle, symboln);
4217     }
4218
4219
4220     if(!disp->VertexAttrib1fARB) {
4221         void ** procp = (void **) &disp->VertexAttrib1fARB;
4222         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1f", symbol_prefix);
4223         *procp = dlsym(handle, symboln);
4224     }
4225
4226
4227     if(!disp->VertexAttrib1fARB) {
4228         void ** procp = (void **) &disp->VertexAttrib1fARB;
4229         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fARB", symbol_prefix);
4230         *procp = dlsym(handle, symboln);
4231     }
4232
4233
4234     if(!disp->VertexAttrib1fvARB) {
4235         void ** procp = (void **) &disp->VertexAttrib1fvARB;
4236         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fv", symbol_prefix);
4237         *procp = dlsym(handle, symboln);
4238     }
4239
4240
4241     if(!disp->VertexAttrib1fvARB) {
4242         void ** procp = (void **) &disp->VertexAttrib1fvARB;
4243         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fvARB", symbol_prefix);
4244         *procp = dlsym(handle, symboln);
4245     }
4246
4247
4248     if(!disp->VertexAttrib1sARB) {
4249         void ** procp = (void **) &disp->VertexAttrib1sARB;
4250         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1s", symbol_prefix);
4251         *procp = dlsym(handle, symboln);
4252     }
4253
4254
4255     if(!disp->VertexAttrib1sARB) {
4256         void ** procp = (void **) &disp->VertexAttrib1sARB;
4257         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1sARB", symbol_prefix);
4258         *procp = dlsym(handle, symboln);
4259     }
4260
4261
4262     if(!disp->VertexAttrib1svARB) {
4263         void ** procp = (void **) &disp->VertexAttrib1svARB;
4264         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1sv", symbol_prefix);
4265         *procp = dlsym(handle, symboln);
4266     }
4267
4268
4269     if(!disp->VertexAttrib1svARB) {
4270         void ** procp = (void **) &disp->VertexAttrib1svARB;
4271         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1svARB", symbol_prefix);
4272         *procp = dlsym(handle, symboln);
4273     }
4274
4275
4276     if(!disp->VertexAttrib2dARB) {
4277         void ** procp = (void **) &disp->VertexAttrib2dARB;
4278         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2d", symbol_prefix);
4279         *procp = dlsym(handle, symboln);
4280     }
4281
4282
4283     if(!disp->VertexAttrib2dARB) {
4284         void ** procp = (void **) &disp->VertexAttrib2dARB;
4285         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dARB", symbol_prefix);
4286         *procp = dlsym(handle, symboln);
4287     }
4288
4289
4290     if(!disp->VertexAttrib2dvARB) {
4291         void ** procp = (void **) &disp->VertexAttrib2dvARB;
4292         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dv", symbol_prefix);
4293         *procp = dlsym(handle, symboln);
4294     }
4295
4296
4297     if(!disp->VertexAttrib2dvARB) {
4298         void ** procp = (void **) &disp->VertexAttrib2dvARB;
4299         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dvARB", symbol_prefix);
4300         *procp = dlsym(handle, symboln);
4301     }
4302
4303
4304     if(!disp->VertexAttrib2fARB) {
4305         void ** procp = (void **) &disp->VertexAttrib2fARB;
4306         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2f", symbol_prefix);
4307         *procp = dlsym(handle, symboln);
4308     }
4309
4310
4311     if(!disp->VertexAttrib2fARB) {
4312         void ** procp = (void **) &disp->VertexAttrib2fARB;
4313         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fARB", symbol_prefix);
4314         *procp = dlsym(handle, symboln);
4315     }
4316
4317
4318     if(!disp->VertexAttrib2fvARB) {
4319         void ** procp = (void **) &disp->VertexAttrib2fvARB;
4320         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fv", symbol_prefix);
4321         *procp = dlsym(handle, symboln);
4322     }
4323
4324
4325     if(!disp->VertexAttrib2fvARB) {
4326         void ** procp = (void **) &disp->VertexAttrib2fvARB;
4327         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fvARB", symbol_prefix);
4328         *procp = dlsym(handle, symboln);
4329     }
4330
4331
4332     if(!disp->VertexAttrib2sARB) {
4333         void ** procp = (void **) &disp->VertexAttrib2sARB;
4334         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2s", symbol_prefix);
4335         *procp = dlsym(handle, symboln);
4336     }
4337
4338
4339     if(!disp->VertexAttrib2sARB) {
4340         void ** procp = (void **) &disp->VertexAttrib2sARB;
4341         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2sARB", symbol_prefix);
4342         *procp = dlsym(handle, symboln);
4343     }
4344
4345
4346     if(!disp->VertexAttrib2svARB) {
4347         void ** procp = (void **) &disp->VertexAttrib2svARB;
4348         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2sv", symbol_prefix);
4349         *procp = dlsym(handle, symboln);
4350     }
4351
4352
4353     if(!disp->VertexAttrib2svARB) {
4354         void ** procp = (void **) &disp->VertexAttrib2svARB;
4355         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2svARB", symbol_prefix);
4356         *procp = dlsym(handle, symboln);
4357     }
4358
4359
4360     if(!disp->VertexAttrib3dARB) {
4361         void ** procp = (void **) &disp->VertexAttrib3dARB;
4362         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3d", symbol_prefix);
4363         *procp = dlsym(handle, symboln);
4364     }
4365
4366
4367     if(!disp->VertexAttrib3dARB) {
4368         void ** procp = (void **) &disp->VertexAttrib3dARB;
4369         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dARB", symbol_prefix);
4370         *procp = dlsym(handle, symboln);
4371     }
4372
4373
4374     if(!disp->VertexAttrib3dvARB) {
4375         void ** procp = (void **) &disp->VertexAttrib3dvARB;
4376         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dv", symbol_prefix);
4377         *procp = dlsym(handle, symboln);
4378     }
4379
4380
4381     if(!disp->VertexAttrib3dvARB) {
4382         void ** procp = (void **) &disp->VertexAttrib3dvARB;
4383         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dvARB", symbol_prefix);
4384         *procp = dlsym(handle, symboln);
4385     }
4386
4387
4388     if(!disp->VertexAttrib3fARB) {
4389         void ** procp = (void **) &disp->VertexAttrib3fARB;
4390         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3f", symbol_prefix);
4391         *procp = dlsym(handle, symboln);
4392     }
4393
4394
4395     if(!disp->VertexAttrib3fARB) {
4396         void ** procp = (void **) &disp->VertexAttrib3fARB;
4397         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fARB", symbol_prefix);
4398         *procp = dlsym(handle, symboln);
4399     }
4400
4401
4402     if(!disp->VertexAttrib3fvARB) {
4403         void ** procp = (void **) &disp->VertexAttrib3fvARB;
4404         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fv", symbol_prefix);
4405         *procp = dlsym(handle, symboln);
4406     }
4407
4408
4409     if(!disp->VertexAttrib3fvARB) {
4410         void ** procp = (void **) &disp->VertexAttrib3fvARB;
4411         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fvARB", symbol_prefix);
4412         *procp = dlsym(handle, symboln);
4413     }
4414
4415
4416     if(!disp->VertexAttrib3sARB) {
4417         void ** procp = (void **) &disp->VertexAttrib3sARB;
4418         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3s", symbol_prefix);
4419         *procp = dlsym(handle, symboln);
4420     }
4421
4422
4423     if(!disp->VertexAttrib3sARB) {
4424         void ** procp = (void **) &disp->VertexAttrib3sARB;
4425         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3sARB", symbol_prefix);
4426         *procp = dlsym(handle, symboln);
4427     }
4428
4429
4430     if(!disp->VertexAttrib3svARB) {
4431         void ** procp = (void **) &disp->VertexAttrib3svARB;
4432         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3sv", symbol_prefix);
4433         *procp = dlsym(handle, symboln);
4434     }
4435
4436
4437     if(!disp->VertexAttrib3svARB) {
4438         void ** procp = (void **) &disp->VertexAttrib3svARB;
4439         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3svARB", symbol_prefix);
4440         *procp = dlsym(handle, symboln);
4441     }
4442
4443
4444     if(!disp->VertexAttrib4NbvARB) {
4445         void ** procp = (void **) &disp->VertexAttrib4NbvARB;
4446         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nbv", symbol_prefix);
4447         *procp = dlsym(handle, symboln);
4448     }
4449
4450
4451     if(!disp->VertexAttrib4NbvARB) {
4452         void ** procp = (void **) &disp->VertexAttrib4NbvARB;
4453         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NbvARB", symbol_prefix);
4454         *procp = dlsym(handle, symboln);
4455     }
4456
4457
4458     if(!disp->VertexAttrib4NivARB) {
4459         void ** procp = (void **) &disp->VertexAttrib4NivARB;
4460         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Niv", symbol_prefix);
4461         *procp = dlsym(handle, symboln);
4462     }
4463
4464
4465     if(!disp->VertexAttrib4NivARB) {
4466         void ** procp = (void **) &disp->VertexAttrib4NivARB;
4467         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NivARB", symbol_prefix);
4468         *procp = dlsym(handle, symboln);
4469     }
4470
4471
4472     if(!disp->VertexAttrib4NsvARB) {
4473         void ** procp = (void **) &disp->VertexAttrib4NsvARB;
4474         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nsv", symbol_prefix);
4475         *procp = dlsym(handle, symboln);
4476     }
4477
4478
4479     if(!disp->VertexAttrib4NsvARB) {
4480         void ** procp = (void **) &disp->VertexAttrib4NsvARB;
4481         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NsvARB", symbol_prefix);
4482         *procp = dlsym(handle, symboln);
4483     }
4484
4485
4486     if(!disp->VertexAttrib4NubARB) {
4487         void ** procp = (void **) &disp->VertexAttrib4NubARB;
4488         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nub", symbol_prefix);
4489         *procp = dlsym(handle, symboln);
4490     }
4491
4492
4493     if(!disp->VertexAttrib4NubARB) {
4494         void ** procp = (void **) &disp->VertexAttrib4NubARB;
4495         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NubARB", symbol_prefix);
4496         *procp = dlsym(handle, symboln);
4497     }
4498
4499
4500     if(!disp->VertexAttrib4NubvARB) {
4501         void ** procp = (void **) &disp->VertexAttrib4NubvARB;
4502         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nubv", symbol_prefix);
4503         *procp = dlsym(handle, symboln);
4504     }
4505
4506
4507     if(!disp->VertexAttrib4NubvARB) {
4508         void ** procp = (void **) &disp->VertexAttrib4NubvARB;
4509         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NubvARB", symbol_prefix);
4510         *procp = dlsym(handle, symboln);
4511     }
4512
4513
4514     if(!disp->VertexAttrib4NuivARB) {
4515         void ** procp = (void **) &disp->VertexAttrib4NuivARB;
4516         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nuiv", symbol_prefix);
4517         *procp = dlsym(handle, symboln);
4518     }
4519
4520
4521     if(!disp->VertexAttrib4NuivARB) {
4522         void ** procp = (void **) &disp->VertexAttrib4NuivARB;
4523         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NuivARB", symbol_prefix);
4524         *procp = dlsym(handle, symboln);
4525     }
4526
4527
4528     if(!disp->VertexAttrib4NusvARB) {
4529         void ** procp = (void **) &disp->VertexAttrib4NusvARB;
4530         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nusv", symbol_prefix);
4531         *procp = dlsym(handle, symboln);
4532     }
4533
4534
4535     if(!disp->VertexAttrib4NusvARB) {
4536         void ** procp = (void **) &disp->VertexAttrib4NusvARB;
4537         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NusvARB", symbol_prefix);
4538         *procp = dlsym(handle, symboln);
4539     }
4540
4541
4542     if(!disp->VertexAttrib4bvARB) {
4543         void ** procp = (void **) &disp->VertexAttrib4bvARB;
4544         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4bv", symbol_prefix);
4545         *procp = dlsym(handle, symboln);
4546     }
4547
4548
4549     if(!disp->VertexAttrib4bvARB) {
4550         void ** procp = (void **) &disp->VertexAttrib4bvARB;
4551         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4bvARB", symbol_prefix);
4552         *procp = dlsym(handle, symboln);
4553     }
4554
4555
4556     if(!disp->VertexAttrib4dARB) {
4557         void ** procp = (void **) &disp->VertexAttrib4dARB;
4558         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4d", symbol_prefix);
4559         *procp = dlsym(handle, symboln);
4560     }
4561
4562
4563     if(!disp->VertexAttrib4dARB) {
4564         void ** procp = (void **) &disp->VertexAttrib4dARB;
4565         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dARB", symbol_prefix);
4566         *procp = dlsym(handle, symboln);
4567     }
4568
4569
4570     if(!disp->VertexAttrib4dvARB) {
4571         void ** procp = (void **) &disp->VertexAttrib4dvARB;
4572         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dv", symbol_prefix);
4573         *procp = dlsym(handle, symboln);
4574     }
4575
4576
4577     if(!disp->VertexAttrib4dvARB) {
4578         void ** procp = (void **) &disp->VertexAttrib4dvARB;
4579         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dvARB", symbol_prefix);
4580         *procp = dlsym(handle, symboln);
4581     }
4582
4583
4584     if(!disp->VertexAttrib4fARB) {
4585         void ** procp = (void **) &disp->VertexAttrib4fARB;
4586         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4f", symbol_prefix);
4587         *procp = dlsym(handle, symboln);
4588     }
4589
4590
4591     if(!disp->VertexAttrib4fARB) {
4592         void ** procp = (void **) &disp->VertexAttrib4fARB;
4593         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fARB", symbol_prefix);
4594         *procp = dlsym(handle, symboln);
4595     }
4596
4597
4598     if(!disp->VertexAttrib4fvARB) {
4599         void ** procp = (void **) &disp->VertexAttrib4fvARB;
4600         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fv", symbol_prefix);
4601         *procp = dlsym(handle, symboln);
4602     }
4603
4604
4605     if(!disp->VertexAttrib4fvARB) {
4606         void ** procp = (void **) &disp->VertexAttrib4fvARB;
4607         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fvARB", symbol_prefix);
4608         *procp = dlsym(handle, symboln);
4609     }
4610
4611
4612     if(!disp->VertexAttrib4ivARB) {
4613         void ** procp = (void **) &disp->VertexAttrib4ivARB;
4614         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4iv", symbol_prefix);
4615         *procp = dlsym(handle, symboln);
4616     }
4617
4618
4619     if(!disp->VertexAttrib4ivARB) {
4620         void ** procp = (void **) &disp->VertexAttrib4ivARB;
4621         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ivARB", symbol_prefix);
4622         *procp = dlsym(handle, symboln);
4623     }
4624
4625
4626     if(!disp->VertexAttrib4sARB) {
4627         void ** procp = (void **) &disp->VertexAttrib4sARB;
4628         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4s", symbol_prefix);
4629         *procp = dlsym(handle, symboln);
4630     }
4631
4632
4633     if(!disp->VertexAttrib4sARB) {
4634         void ** procp = (void **) &disp->VertexAttrib4sARB;
4635         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4sARB", symbol_prefix);
4636         *procp = dlsym(handle, symboln);
4637     }
4638
4639
4640     if(!disp->VertexAttrib4svARB) {
4641         void ** procp = (void **) &disp->VertexAttrib4svARB;
4642         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4sv", symbol_prefix);
4643         *procp = dlsym(handle, symboln);
4644     }
4645
4646
4647     if(!disp->VertexAttrib4svARB) {
4648         void ** procp = (void **) &disp->VertexAttrib4svARB;
4649         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4svARB", symbol_prefix);
4650         *procp = dlsym(handle, symboln);
4651     }
4652
4653
4654     if(!disp->VertexAttrib4ubvARB) {
4655         void ** procp = (void **) &disp->VertexAttrib4ubvARB;
4656         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubv", symbol_prefix);
4657         *procp = dlsym(handle, symboln);
4658     }
4659
4660
4661     if(!disp->VertexAttrib4ubvARB) {
4662         void ** procp = (void **) &disp->VertexAttrib4ubvARB;
4663         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubvARB", symbol_prefix);
4664         *procp = dlsym(handle, symboln);
4665     }
4666
4667
4668     if(!disp->VertexAttrib4uivARB) {
4669         void ** procp = (void **) &disp->VertexAttrib4uivARB;
4670         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4uiv", symbol_prefix);
4671         *procp = dlsym(handle, symboln);
4672     }
4673
4674
4675     if(!disp->VertexAttrib4uivARB) {
4676         void ** procp = (void **) &disp->VertexAttrib4uivARB;
4677         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4uivARB", symbol_prefix);
4678         *procp = dlsym(handle, symboln);
4679     }
4680
4681
4682     if(!disp->VertexAttrib4usvARB) {
4683         void ** procp = (void **) &disp->VertexAttrib4usvARB;
4684         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4usv", symbol_prefix);
4685         *procp = dlsym(handle, symboln);
4686     }
4687
4688
4689     if(!disp->VertexAttrib4usvARB) {
4690         void ** procp = (void **) &disp->VertexAttrib4usvARB;
4691         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4usvARB", symbol_prefix);
4692         *procp = dlsym(handle, symboln);
4693     }
4694
4695
4696     if(!disp->VertexAttribPointerARB) {
4697         void ** procp = (void **) &disp->VertexAttribPointerARB;
4698         snprintf(symboln, sizeof(symboln), "%sVertexAttribPointer", symbol_prefix);
4699         *procp = dlsym(handle, symboln);
4700     }
4701
4702
4703     if(!disp->VertexAttribPointerARB) {
4704         void ** procp = (void **) &disp->VertexAttribPointerARB;
4705         snprintf(symboln, sizeof(symboln), "%sVertexAttribPointerARB", symbol_prefix);
4706         *procp = dlsym(handle, symboln);
4707     }
4708
4709
4710     if(!disp->BindBufferARB) {
4711         void ** procp = (void **) &disp->BindBufferARB;
4712         snprintf(symboln, sizeof(symboln), "%sBindBuffer", symbol_prefix);
4713         *procp = dlsym(handle, symboln);
4714     }
4715
4716
4717     if(!disp->BindBufferARB) {
4718         void ** procp = (void **) &disp->BindBufferARB;
4719         snprintf(symboln, sizeof(symboln), "%sBindBufferARB", symbol_prefix);
4720         *procp = dlsym(handle, symboln);
4721     }
4722
4723
4724     if(!disp->BufferDataARB) {
4725         void ** procp = (void **) &disp->BufferDataARB;
4726         snprintf(symboln, sizeof(symboln), "%sBufferData", symbol_prefix);
4727         *procp = dlsym(handle, symboln);
4728     }
4729
4730
4731     if(!disp->BufferDataARB) {
4732         void ** procp = (void **) &disp->BufferDataARB;
4733         snprintf(symboln, sizeof(symboln), "%sBufferDataARB", symbol_prefix);
4734         *procp = dlsym(handle, symboln);
4735     }
4736
4737
4738     if(!disp->BufferSubDataARB) {
4739         void ** procp = (void **) &disp->BufferSubDataARB;
4740         snprintf(symboln, sizeof(symboln), "%sBufferSubData", symbol_prefix);
4741         *procp = dlsym(handle, symboln);
4742     }
4743
4744
4745     if(!disp->BufferSubDataARB) {
4746         void ** procp = (void **) &disp->BufferSubDataARB;
4747         snprintf(symboln, sizeof(symboln), "%sBufferSubDataARB", symbol_prefix);
4748         *procp = dlsym(handle, symboln);
4749     }
4750
4751
4752     if(!disp->DeleteBuffersARB) {
4753         void ** procp = (void **) &disp->DeleteBuffersARB;
4754         snprintf(symboln, sizeof(symboln), "%sDeleteBuffers", symbol_prefix);
4755         *procp = dlsym(handle, symboln);
4756     }
4757
4758
4759     if(!disp->DeleteBuffersARB) {
4760         void ** procp = (void **) &disp->DeleteBuffersARB;
4761         snprintf(symboln, sizeof(symboln), "%sDeleteBuffersARB", symbol_prefix);
4762         *procp = dlsym(handle, symboln);
4763     }
4764
4765
4766     if(!disp->GenBuffersARB) {
4767         void ** procp = (void **) &disp->GenBuffersARB;
4768         snprintf(symboln, sizeof(symboln), "%sGenBuffers", symbol_prefix);
4769         *procp = dlsym(handle, symboln);
4770     }
4771
4772
4773     if(!disp->GenBuffersARB) {
4774         void ** procp = (void **) &disp->GenBuffersARB;
4775         snprintf(symboln, sizeof(symboln), "%sGenBuffersARB", symbol_prefix);
4776         *procp = dlsym(handle, symboln);
4777     }
4778
4779
4780     if(!disp->GetBufferParameterivARB) {
4781         void ** procp = (void **) &disp->GetBufferParameterivARB;
4782         snprintf(symboln, sizeof(symboln), "%sGetBufferParameteriv", symbol_prefix);
4783         *procp = dlsym(handle, symboln);
4784     }
4785
4786
4787     if(!disp->GetBufferParameterivARB) {
4788         void ** procp = (void **) &disp->GetBufferParameterivARB;
4789         snprintf(symboln, sizeof(symboln), "%sGetBufferParameterivARB", symbol_prefix);
4790         *procp = dlsym(handle, symboln);
4791     }
4792
4793
4794     if(!disp->GetBufferPointervARB) {
4795         void ** procp = (void **) &disp->GetBufferPointervARB;
4796         snprintf(symboln, sizeof(symboln), "%sGetBufferPointerv", symbol_prefix);
4797         *procp = dlsym(handle, symboln);
4798     }
4799
4800
4801     if(!disp->GetBufferPointervARB) {
4802         void ** procp = (void **) &disp->GetBufferPointervARB;
4803         snprintf(symboln, sizeof(symboln), "%sGetBufferPointervARB", symbol_prefix);
4804         *procp = dlsym(handle, symboln);
4805     }
4806
4807
4808     if(!disp->GetBufferSubDataARB) {
4809         void ** procp = (void **) &disp->GetBufferSubDataARB;
4810         snprintf(symboln, sizeof(symboln), "%sGetBufferSubData", symbol_prefix);
4811         *procp = dlsym(handle, symboln);
4812     }
4813
4814
4815     if(!disp->GetBufferSubDataARB) {
4816         void ** procp = (void **) &disp->GetBufferSubDataARB;
4817         snprintf(symboln, sizeof(symboln), "%sGetBufferSubDataARB", symbol_prefix);
4818         *procp = dlsym(handle, symboln);
4819     }
4820
4821
4822     if(!disp->IsBufferARB) {
4823         void ** procp = (void **) &disp->IsBufferARB;
4824         snprintf(symboln, sizeof(symboln), "%sIsBuffer", symbol_prefix);
4825         *procp = dlsym(handle, symboln);
4826     }
4827
4828
4829     if(!disp->IsBufferARB) {
4830         void ** procp = (void **) &disp->IsBufferARB;
4831         snprintf(symboln, sizeof(symboln), "%sIsBufferARB", symbol_prefix);
4832         *procp = dlsym(handle, symboln);
4833     }
4834
4835
4836     if(!disp->MapBufferARB) {
4837         void ** procp = (void **) &disp->MapBufferARB;
4838         snprintf(symboln, sizeof(symboln), "%sMapBuffer", symbol_prefix);
4839         *procp = dlsym(handle, symboln);
4840     }
4841
4842
4843     if(!disp->MapBufferARB) {
4844         void ** procp = (void **) &disp->MapBufferARB;
4845         snprintf(symboln, sizeof(symboln), "%sMapBufferARB", symbol_prefix);
4846         *procp = dlsym(handle, symboln);
4847     }
4848
4849
4850     if(!disp->UnmapBufferARB) {
4851         void ** procp = (void **) &disp->UnmapBufferARB;
4852         snprintf(symboln, sizeof(symboln), "%sUnmapBuffer", symbol_prefix);
4853         *procp = dlsym(handle, symboln);
4854     }
4855
4856
4857     if(!disp->UnmapBufferARB) {
4858         void ** procp = (void **) &disp->UnmapBufferARB;
4859         snprintf(symboln, sizeof(symboln), "%sUnmapBufferARB", symbol_prefix);
4860         *procp = dlsym(handle, symboln);
4861     }
4862
4863
4864     if(!disp->BeginQueryARB) {
4865         void ** procp = (void **) &disp->BeginQueryARB;
4866         snprintf(symboln, sizeof(symboln), "%sBeginQuery", symbol_prefix);
4867         *procp = dlsym(handle, symboln);
4868     }
4869
4870
4871     if(!disp->BeginQueryARB) {
4872         void ** procp = (void **) &disp->BeginQueryARB;
4873         snprintf(symboln, sizeof(symboln), "%sBeginQueryARB", symbol_prefix);
4874         *procp = dlsym(handle, symboln);
4875     }
4876
4877
4878     if(!disp->DeleteQueriesARB) {
4879         void ** procp = (void **) &disp->DeleteQueriesARB;
4880         snprintf(symboln, sizeof(symboln), "%sDeleteQueries", symbol_prefix);
4881         *procp = dlsym(handle, symboln);
4882     }
4883
4884
4885     if(!disp->DeleteQueriesARB) {
4886         void ** procp = (void **) &disp->DeleteQueriesARB;
4887         snprintf(symboln, sizeof(symboln), "%sDeleteQueriesARB", symbol_prefix);
4888         *procp = dlsym(handle, symboln);
4889     }
4890
4891
4892     if(!disp->EndQueryARB) {
4893         void ** procp = (void **) &disp->EndQueryARB;
4894         snprintf(symboln, sizeof(symboln), "%sEndQuery", symbol_prefix);
4895         *procp = dlsym(handle, symboln);
4896     }
4897
4898
4899     if(!disp->EndQueryARB) {
4900         void ** procp = (void **) &disp->EndQueryARB;
4901         snprintf(symboln, sizeof(symboln), "%sEndQueryARB", symbol_prefix);
4902         *procp = dlsym(handle, symboln);
4903     }
4904
4905
4906     if(!disp->GenQueriesARB) {
4907         void ** procp = (void **) &disp->GenQueriesARB;
4908         snprintf(symboln, sizeof(symboln), "%sGenQueries", symbol_prefix);
4909         *procp = dlsym(handle, symboln);
4910     }
4911
4912
4913     if(!disp->GenQueriesARB) {
4914         void ** procp = (void **) &disp->GenQueriesARB;
4915         snprintf(symboln, sizeof(symboln), "%sGenQueriesARB", symbol_prefix);
4916         *procp = dlsym(handle, symboln);
4917     }
4918
4919
4920     if(!disp->GetQueryObjectivARB) {
4921         void ** procp = (void **) &disp->GetQueryObjectivARB;
4922         snprintf(symboln, sizeof(symboln), "%sGetQueryObjectiv", symbol_prefix);
4923         *procp = dlsym(handle, symboln);
4924     }
4925
4926
4927     if(!disp->GetQueryObjectivARB) {
4928         void ** procp = (void **) &disp->GetQueryObjectivARB;
4929         snprintf(symboln, sizeof(symboln), "%sGetQueryObjectivARB", symbol_prefix);
4930         *procp = dlsym(handle, symboln);
4931     }
4932
4933
4934     if(!disp->GetQueryObjectuivARB) {
4935         void ** procp = (void **) &disp->GetQueryObjectuivARB;
4936         snprintf(symboln, sizeof(symboln), "%sGetQueryObjectuiv", symbol_prefix);
4937         *procp = dlsym(handle, symboln);
4938     }
4939
4940
4941     if(!disp->GetQueryObjectuivARB) {
4942         void ** procp = (void **) &disp->GetQueryObjectuivARB;
4943         snprintf(symboln, sizeof(symboln), "%sGetQueryObjectuivARB", symbol_prefix);
4944         *procp = dlsym(handle, symboln);
4945     }
4946
4947
4948     if(!disp->GetQueryivARB) {
4949         void ** procp = (void **) &disp->GetQueryivARB;
4950         snprintf(symboln, sizeof(symboln), "%sGetQueryiv", symbol_prefix);
4951         *procp = dlsym(handle, symboln);
4952     }
4953
4954
4955     if(!disp->GetQueryivARB) {
4956         void ** procp = (void **) &disp->GetQueryivARB;
4957         snprintf(symboln, sizeof(symboln), "%sGetQueryivARB", symbol_prefix);
4958         *procp = dlsym(handle, symboln);
4959     }
4960
4961
4962     if(!disp->IsQueryARB) {
4963         void ** procp = (void **) &disp->IsQueryARB;
4964         snprintf(symboln, sizeof(symboln), "%sIsQuery", symbol_prefix);
4965         *procp = dlsym(handle, symboln);
4966     }
4967
4968
4969     if(!disp->IsQueryARB) {
4970         void ** procp = (void **) &disp->IsQueryARB;
4971         snprintf(symboln, sizeof(symboln), "%sIsQueryARB", symbol_prefix);
4972         *procp = dlsym(handle, symboln);
4973     }
4974
4975
4976     if(!disp->AttachObjectARB) {
4977         void ** procp = (void **) &disp->AttachObjectARB;
4978         snprintf(symboln, sizeof(symboln), "%sAttachObjectARB", symbol_prefix);
4979         *procp = dlsym(handle, symboln);
4980     }
4981
4982
4983     if(!disp->CompileShaderARB) {
4984         void ** procp = (void **) &disp->CompileShaderARB;
4985         snprintf(symboln, sizeof(symboln), "%sCompileShader", symbol_prefix);
4986         *procp = dlsym(handle, symboln);
4987     }
4988
4989
4990     if(!disp->CompileShaderARB) {
4991         void ** procp = (void **) &disp->CompileShaderARB;
4992         snprintf(symboln, sizeof(symboln), "%sCompileShaderARB", symbol_prefix);
4993         *procp = dlsym(handle, symboln);
4994     }
4995
4996
4997     if(!disp->CreateProgramObjectARB) {
4998         void ** procp = (void **) &disp->CreateProgramObjectARB;
4999         snprintf(symboln, sizeof(symboln), "%sCreateProgramObjectARB", symbol_prefix);
5000         *procp = dlsym(handle, symboln);
5001     }
5002
5003
5004     if(!disp->CreateShaderObjectARB) {
5005         void ** procp = (void **) &disp->CreateShaderObjectARB;
5006         snprintf(symboln, sizeof(symboln), "%sCreateShaderObjectARB", symbol_prefix);
5007         *procp = dlsym(handle, symboln);
5008     }
5009
5010
5011     if(!disp->DeleteObjectARB) {
5012         void ** procp = (void **) &disp->DeleteObjectARB;
5013         snprintf(symboln, sizeof(symboln), "%sDeleteObjectARB", symbol_prefix);
5014         *procp = dlsym(handle, symboln);
5015     }
5016
5017
5018     if(!disp->DetachObjectARB) {
5019         void ** procp = (void **) &disp->DetachObjectARB;
5020         snprintf(symboln, sizeof(symboln), "%sDetachObjectARB", symbol_prefix);
5021         *procp = dlsym(handle, symboln);
5022     }
5023
5024
5025     if(!disp->GetActiveUniformARB) {
5026         void ** procp = (void **) &disp->GetActiveUniformARB;
5027         snprintf(symboln, sizeof(symboln), "%sGetActiveUniform", symbol_prefix);
5028         *procp = dlsym(handle, symboln);
5029     }
5030
5031
5032     if(!disp->GetActiveUniformARB) {
5033         void ** procp = (void **) &disp->GetActiveUniformARB;
5034         snprintf(symboln, sizeof(symboln), "%sGetActiveUniformARB", symbol_prefix);
5035         *procp = dlsym(handle, symboln);
5036     }
5037
5038
5039     if(!disp->GetAttachedObjectsARB) {
5040         void ** procp = (void **) &disp->GetAttachedObjectsARB;
5041         snprintf(symboln, sizeof(symboln), "%sGetAttachedObjectsARB", symbol_prefix);
5042         *procp = dlsym(handle, symboln);
5043     }
5044
5045
5046     if(!disp->GetHandleARB) {
5047         void ** procp = (void **) &disp->GetHandleARB;
5048         snprintf(symboln, sizeof(symboln), "%sGetHandleARB", symbol_prefix);
5049         *procp = dlsym(handle, symboln);
5050     }
5051
5052
5053     if(!disp->GetInfoLogARB) {
5054         void ** procp = (void **) &disp->GetInfoLogARB;
5055         snprintf(symboln, sizeof(symboln), "%sGetInfoLogARB", symbol_prefix);
5056         *procp = dlsym(handle, symboln);
5057     }
5058
5059
5060     if(!disp->GetObjectParameterfvARB) {
5061         void ** procp = (void **) &disp->GetObjectParameterfvARB;
5062         snprintf(symboln, sizeof(symboln), "%sGetObjectParameterfvARB", symbol_prefix);
5063         *procp = dlsym(handle, symboln);
5064     }
5065
5066
5067     if(!disp->GetObjectParameterivARB) {
5068         void ** procp = (void **) &disp->GetObjectParameterivARB;
5069         snprintf(symboln, sizeof(symboln), "%sGetObjectParameterivARB", symbol_prefix);
5070         *procp = dlsym(handle, symboln);
5071     }
5072
5073
5074     if(!disp->GetShaderSourceARB) {
5075         void ** procp = (void **) &disp->GetShaderSourceARB;
5076         snprintf(symboln, sizeof(symboln), "%sGetShaderSource", symbol_prefix);
5077         *procp = dlsym(handle, symboln);
5078     }
5079
5080
5081     if(!disp->GetShaderSourceARB) {
5082         void ** procp = (void **) &disp->GetShaderSourceARB;
5083         snprintf(symboln, sizeof(symboln), "%sGetShaderSourceARB", symbol_prefix);
5084         *procp = dlsym(handle, symboln);
5085     }
5086
5087
5088     if(!disp->GetUniformLocationARB) {
5089         void ** procp = (void **) &disp->GetUniformLocationARB;
5090         snprintf(symboln, sizeof(symboln), "%sGetUniformLocation", symbol_prefix);
5091         *procp = dlsym(handle, symboln);
5092     }
5093
5094
5095     if(!disp->GetUniformLocationARB) {
5096         void ** procp = (void **) &disp->GetUniformLocationARB;
5097         snprintf(symboln, sizeof(symboln), "%sGetUniformLocationARB", symbol_prefix);
5098         *procp = dlsym(handle, symboln);
5099     }
5100
5101
5102     if(!disp->GetUniformfvARB) {
5103         void ** procp = (void **) &disp->GetUniformfvARB;
5104         snprintf(symboln, sizeof(symboln), "%sGetUniformfv", symbol_prefix);
5105         *procp = dlsym(handle, symboln);
5106     }
5107
5108
5109     if(!disp->GetUniformfvARB) {
5110         void ** procp = (void **) &disp->GetUniformfvARB;
5111         snprintf(symboln, sizeof(symboln), "%sGetUniformfvARB", symbol_prefix);
5112         *procp = dlsym(handle, symboln);
5113     }
5114
5115
5116     if(!disp->GetUniformivARB) {
5117         void ** procp = (void **) &disp->GetUniformivARB;
5118         snprintf(symboln, sizeof(symboln), "%sGetUniformiv", symbol_prefix);
5119         *procp = dlsym(handle, symboln);
5120     }
5121
5122
5123     if(!disp->GetUniformivARB) {
5124         void ** procp = (void **) &disp->GetUniformivARB;
5125         snprintf(symboln, sizeof(symboln), "%sGetUniformivARB", symbol_prefix);
5126         *procp = dlsym(handle, symboln);
5127     }
5128
5129
5130     if(!disp->LinkProgramARB) {
5131         void ** procp = (void **) &disp->LinkProgramARB;
5132         snprintf(symboln, sizeof(symboln), "%sLinkProgram", symbol_prefix);
5133         *procp = dlsym(handle, symboln);
5134     }
5135
5136
5137     if(!disp->LinkProgramARB) {
5138         void ** procp = (void **) &disp->LinkProgramARB;
5139         snprintf(symboln, sizeof(symboln), "%sLinkProgramARB", symbol_prefix);
5140         *procp = dlsym(handle, symboln);
5141     }
5142
5143
5144     if(!disp->ShaderSourceARB) {
5145         void ** procp = (void **) &disp->ShaderSourceARB;
5146         snprintf(symboln, sizeof(symboln), "%sShaderSource", symbol_prefix);
5147         *procp = dlsym(handle, symboln);
5148     }
5149
5150
5151     if(!disp->ShaderSourceARB) {
5152         void ** procp = (void **) &disp->ShaderSourceARB;
5153         snprintf(symboln, sizeof(symboln), "%sShaderSourceARB", symbol_prefix);
5154         *procp = dlsym(handle, symboln);
5155     }
5156
5157
5158     if(!disp->Uniform1fARB) {
5159         void ** procp = (void **) &disp->Uniform1fARB;
5160         snprintf(symboln, sizeof(symboln), "%sUniform1f", symbol_prefix);
5161         *procp = dlsym(handle, symboln);
5162     }
5163
5164
5165     if(!disp->Uniform1fARB) {
5166         void ** procp = (void **) &disp->Uniform1fARB;
5167         snprintf(symboln, sizeof(symboln), "%sUniform1fARB", symbol_prefix);
5168         *procp = dlsym(handle, symboln);
5169     }
5170
5171
5172     if(!disp->Uniform1fvARB) {
5173         void ** procp = (void **) &disp->Uniform1fvARB;
5174         snprintf(symboln, sizeof(symboln), "%sUniform1fv", symbol_prefix);
5175         *procp = dlsym(handle, symboln);
5176     }
5177
5178
5179     if(!disp->Uniform1fvARB) {
5180         void ** procp = (void **) &disp->Uniform1fvARB;
5181         snprintf(symboln, sizeof(symboln), "%sUniform1fvARB", symbol_prefix);
5182         *procp = dlsym(handle, symboln);
5183     }
5184
5185
5186     if(!disp->Uniform1iARB) {
5187         void ** procp = (void **) &disp->Uniform1iARB;
5188         snprintf(symboln, sizeof(symboln), "%sUniform1i", symbol_prefix);
5189         *procp = dlsym(handle, symboln);
5190     }
5191
5192
5193     if(!disp->Uniform1iARB) {
5194         void ** procp = (void **) &disp->Uniform1iARB;
5195         snprintf(symboln, sizeof(symboln), "%sUniform1iARB", symbol_prefix);
5196         *procp = dlsym(handle, symboln);
5197     }
5198
5199
5200     if(!disp->Uniform1ivARB) {
5201         void ** procp = (void **) &disp->Uniform1ivARB;
5202         snprintf(symboln, sizeof(symboln), "%sUniform1iv", symbol_prefix);
5203         *procp = dlsym(handle, symboln);
5204     }
5205
5206
5207     if(!disp->Uniform1ivARB) {
5208         void ** procp = (void **) &disp->Uniform1ivARB;
5209         snprintf(symboln, sizeof(symboln), "%sUniform1ivARB", symbol_prefix);
5210         *procp = dlsym(handle, symboln);
5211     }
5212
5213
5214     if(!disp->Uniform2fARB) {
5215         void ** procp = (void **) &disp->Uniform2fARB;
5216         snprintf(symboln, sizeof(symboln), "%sUniform2f", symbol_prefix);
5217         *procp = dlsym(handle, symboln);
5218     }
5219
5220
5221     if(!disp->Uniform2fARB) {
5222         void ** procp = (void **) &disp->Uniform2fARB;
5223         snprintf(symboln, sizeof(symboln), "%sUniform2fARB", symbol_prefix);
5224         *procp = dlsym(handle, symboln);
5225     }
5226
5227
5228     if(!disp->Uniform2fvARB) {
5229         void ** procp = (void **) &disp->Uniform2fvARB;
5230         snprintf(symboln, sizeof(symboln), "%sUniform2fv", symbol_prefix);
5231         *procp = dlsym(handle, symboln);
5232     }
5233
5234
5235     if(!disp->Uniform2fvARB) {
5236         void ** procp = (void **) &disp->Uniform2fvARB;
5237         snprintf(symboln, sizeof(symboln), "%sUniform2fvARB", symbol_prefix);
5238         *procp = dlsym(handle, symboln);
5239     }
5240
5241
5242     if(!disp->Uniform2iARB) {
5243         void ** procp = (void **) &disp->Uniform2iARB;
5244         snprintf(symboln, sizeof(symboln), "%sUniform2i", symbol_prefix);
5245         *procp = dlsym(handle, symboln);
5246     }
5247
5248
5249     if(!disp->Uniform2iARB) {
5250         void ** procp = (void **) &disp->Uniform2iARB;
5251         snprintf(symboln, sizeof(symboln), "%sUniform2iARB", symbol_prefix);
5252         *procp = dlsym(handle, symboln);
5253     }
5254
5255
5256     if(!disp->Uniform2ivARB) {
5257         void ** procp = (void **) &disp->Uniform2ivARB;
5258         snprintf(symboln, sizeof(symboln), "%sUniform2iv", symbol_prefix);
5259         *procp = dlsym(handle, symboln);
5260     }
5261
5262
5263     if(!disp->Uniform2ivARB) {
5264         void ** procp = (void **) &disp->Uniform2ivARB;
5265         snprintf(symboln, sizeof(symboln), "%sUniform2ivARB", symbol_prefix);
5266         *procp = dlsym(handle, symboln);
5267     }
5268
5269
5270     if(!disp->Uniform3fARB) {
5271         void ** procp = (void **) &disp->Uniform3fARB;
5272         snprintf(symboln, sizeof(symboln), "%sUniform3f", symbol_prefix);
5273         *procp = dlsym(handle, symboln);
5274     }
5275
5276
5277     if(!disp->Uniform3fARB) {
5278         void ** procp = (void **) &disp->Uniform3fARB;
5279         snprintf(symboln, sizeof(symboln), "%sUniform3fARB", symbol_prefix);
5280         *procp = dlsym(handle, symboln);
5281     }
5282
5283
5284     if(!disp->Uniform3fvARB) {
5285         void ** procp = (void **) &disp->Uniform3fvARB;
5286         snprintf(symboln, sizeof(symboln), "%sUniform3fv", symbol_prefix);
5287         *procp = dlsym(handle, symboln);
5288     }
5289
5290
5291     if(!disp->Uniform3fvARB) {
5292         void ** procp = (void **) &disp->Uniform3fvARB;
5293         snprintf(symboln, sizeof(symboln), "%sUniform3fvARB", symbol_prefix);
5294         *procp = dlsym(handle, symboln);
5295     }
5296
5297
5298     if(!disp->Uniform3iARB) {
5299         void ** procp = (void **) &disp->Uniform3iARB;
5300         snprintf(symboln, sizeof(symboln), "%sUniform3i", symbol_prefix);
5301         *procp = dlsym(handle, symboln);
5302     }
5303
5304
5305     if(!disp->Uniform3iARB) {
5306         void ** procp = (void **) &disp->Uniform3iARB;
5307         snprintf(symboln, sizeof(symboln), "%sUniform3iARB", symbol_prefix);
5308         *procp = dlsym(handle, symboln);
5309     }
5310
5311
5312     if(!disp->Uniform3ivARB) {
5313         void ** procp = (void **) &disp->Uniform3ivARB;
5314         snprintf(symboln, sizeof(symboln), "%sUniform3iv", symbol_prefix);
5315         *procp = dlsym(handle, symboln);
5316     }
5317
5318
5319     if(!disp->Uniform3ivARB) {
5320         void ** procp = (void **) &disp->Uniform3ivARB;
5321         snprintf(symboln, sizeof(symboln), "%sUniform3ivARB", symbol_prefix);
5322         *procp = dlsym(handle, symboln);
5323     }
5324
5325
5326     if(!disp->Uniform4fARB) {
5327         void ** procp = (void **) &disp->Uniform4fARB;
5328         snprintf(symboln, sizeof(symboln), "%sUniform4f", symbol_prefix);
5329         *procp = dlsym(handle, symboln);
5330     }
5331
5332
5333     if(!disp->Uniform4fARB) {
5334         void ** procp = (void **) &disp->Uniform4fARB;
5335         snprintf(symboln, sizeof(symboln), "%sUniform4fARB", symbol_prefix);
5336         *procp = dlsym(handle, symboln);
5337     }
5338
5339
5340     if(!disp->Uniform4fvARB) {
5341         void ** procp = (void **) &disp->Uniform4fvARB;
5342         snprintf(symboln, sizeof(symboln), "%sUniform4fv", symbol_prefix);
5343         *procp = dlsym(handle, symboln);
5344     }
5345
5346
5347     if(!disp->Uniform4fvARB) {
5348         void ** procp = (void **) &disp->Uniform4fvARB;
5349         snprintf(symboln, sizeof(symboln), "%sUniform4fvARB", symbol_prefix);
5350         *procp = dlsym(handle, symboln);
5351     }
5352
5353
5354     if(!disp->Uniform4iARB) {
5355         void ** procp = (void **) &disp->Uniform4iARB;
5356         snprintf(symboln, sizeof(symboln), "%sUniform4i", symbol_prefix);
5357         *procp = dlsym(handle, symboln);
5358     }
5359
5360
5361     if(!disp->Uniform4iARB) {
5362         void ** procp = (void **) &disp->Uniform4iARB;
5363         snprintf(symboln, sizeof(symboln), "%sUniform4iARB", symbol_prefix);
5364         *procp = dlsym(handle, symboln);
5365     }
5366
5367
5368     if(!disp->Uniform4ivARB) {
5369         void ** procp = (void **) &disp->Uniform4ivARB;
5370         snprintf(symboln, sizeof(symboln), "%sUniform4iv", symbol_prefix);
5371         *procp = dlsym(handle, symboln);
5372     }
5373
5374
5375     if(!disp->Uniform4ivARB) {
5376         void ** procp = (void **) &disp->Uniform4ivARB;
5377         snprintf(symboln, sizeof(symboln), "%sUniform4ivARB", symbol_prefix);
5378         *procp = dlsym(handle, symboln);
5379     }
5380
5381
5382     if(!disp->UniformMatrix2fvARB) {
5383         void ** procp = (void **) &disp->UniformMatrix2fvARB;
5384         snprintf(symboln, sizeof(symboln), "%sUniformMatrix2fv", symbol_prefix);
5385         *procp = dlsym(handle, symboln);
5386     }
5387
5388
5389     if(!disp->UniformMatrix2fvARB) {
5390         void ** procp = (void **) &disp->UniformMatrix2fvARB;
5391         snprintf(symboln, sizeof(symboln), "%sUniformMatrix2fvARB", symbol_prefix);
5392         *procp = dlsym(handle, symboln);
5393     }
5394
5395
5396     if(!disp->UniformMatrix3fvARB) {
5397         void ** procp = (void **) &disp->UniformMatrix3fvARB;
5398         snprintf(symboln, sizeof(symboln), "%sUniformMatrix3fv", symbol_prefix);
5399         *procp = dlsym(handle, symboln);
5400     }
5401
5402
5403     if(!disp->UniformMatrix3fvARB) {
5404         void ** procp = (void **) &disp->UniformMatrix3fvARB;
5405         snprintf(symboln, sizeof(symboln), "%sUniformMatrix3fvARB", symbol_prefix);
5406         *procp = dlsym(handle, symboln);
5407     }
5408
5409
5410     if(!disp->UniformMatrix4fvARB) {
5411         void ** procp = (void **) &disp->UniformMatrix4fvARB;
5412         snprintf(symboln, sizeof(symboln), "%sUniformMatrix4fv", symbol_prefix);
5413         *procp = dlsym(handle, symboln);
5414     }
5415
5416
5417     if(!disp->UniformMatrix4fvARB) {
5418         void ** procp = (void **) &disp->UniformMatrix4fvARB;
5419         snprintf(symboln, sizeof(symboln), "%sUniformMatrix4fvARB", symbol_prefix);
5420         *procp = dlsym(handle, symboln);
5421     }
5422
5423
5424     if(!disp->UseProgramObjectARB) {
5425         void ** procp = (void **) &disp->UseProgramObjectARB;
5426         snprintf(symboln, sizeof(symboln), "%sUseProgram", symbol_prefix);
5427         *procp = dlsym(handle, symboln);
5428     }
5429
5430
5431     if(!disp->UseProgramObjectARB) {
5432         void ** procp = (void **) &disp->UseProgramObjectARB;
5433         snprintf(symboln, sizeof(symboln), "%sUseProgramObjectARB", symbol_prefix);
5434         *procp = dlsym(handle, symboln);
5435     }
5436
5437
5438     if(!disp->ValidateProgramARB) {
5439         void ** procp = (void **) &disp->ValidateProgramARB;
5440         snprintf(symboln, sizeof(symboln), "%sValidateProgram", symbol_prefix);
5441         *procp = dlsym(handle, symboln);
5442     }
5443
5444
5445     if(!disp->ValidateProgramARB) {
5446         void ** procp = (void **) &disp->ValidateProgramARB;
5447         snprintf(symboln, sizeof(symboln), "%sValidateProgramARB", symbol_prefix);
5448         *procp = dlsym(handle, symboln);
5449     }
5450
5451
5452     if(!disp->BindAttribLocationARB) {
5453         void ** procp = (void **) &disp->BindAttribLocationARB;
5454         snprintf(symboln, sizeof(symboln), "%sBindAttribLocation", symbol_prefix);
5455         *procp = dlsym(handle, symboln);
5456     }
5457
5458
5459     if(!disp->BindAttribLocationARB) {
5460         void ** procp = (void **) &disp->BindAttribLocationARB;
5461         snprintf(symboln, sizeof(symboln), "%sBindAttribLocationARB", symbol_prefix);
5462         *procp = dlsym(handle, symboln);
5463     }
5464
5465
5466     if(!disp->GetActiveAttribARB) {
5467         void ** procp = (void **) &disp->GetActiveAttribARB;
5468         snprintf(symboln, sizeof(symboln), "%sGetActiveAttrib", symbol_prefix);
5469         *procp = dlsym(handle, symboln);
5470     }
5471
5472
5473     if(!disp->GetActiveAttribARB) {
5474         void ** procp = (void **) &disp->GetActiveAttribARB;
5475         snprintf(symboln, sizeof(symboln), "%sGetActiveAttribARB", symbol_prefix);
5476         *procp = dlsym(handle, symboln);
5477     }
5478
5479
5480     if(!disp->GetAttribLocationARB) {
5481         void ** procp = (void **) &disp->GetAttribLocationARB;
5482         snprintf(symboln, sizeof(symboln), "%sGetAttribLocation", symbol_prefix);
5483         *procp = dlsym(handle, symboln);
5484     }
5485
5486
5487     if(!disp->GetAttribLocationARB) {
5488         void ** procp = (void **) &disp->GetAttribLocationARB;
5489         snprintf(symboln, sizeof(symboln), "%sGetAttribLocationARB", symbol_prefix);
5490         *procp = dlsym(handle, symboln);
5491     }
5492
5493
5494     if(!disp->DrawBuffersARB) {
5495         void ** procp = (void **) &disp->DrawBuffersARB;
5496         snprintf(symboln, sizeof(symboln), "%sDrawBuffers", symbol_prefix);
5497         *procp = dlsym(handle, symboln);
5498     }
5499
5500
5501     if(!disp->DrawBuffersARB) {
5502         void ** procp = (void **) &disp->DrawBuffersARB;
5503         snprintf(symboln, sizeof(symboln), "%sDrawBuffersARB", symbol_prefix);
5504         *procp = dlsym(handle, symboln);
5505     }
5506
5507
5508     if(!disp->DrawBuffersARB) {
5509         void ** procp = (void **) &disp->DrawBuffersARB;
5510         snprintf(symboln, sizeof(symboln), "%sDrawBuffersATI", symbol_prefix);
5511         *procp = dlsym(handle, symboln);
5512     }
5513
5514
5515     if(!disp->ClampColorARB) {
5516         void ** procp = (void **) &disp->ClampColorARB;
5517         snprintf(symboln, sizeof(symboln), "%sClampColorARB", symbol_prefix);
5518         *procp = dlsym(handle, symboln);
5519     }
5520
5521
5522     if(!disp->DrawArraysInstancedARB) {
5523         void ** procp = (void **) &disp->DrawArraysInstancedARB;
5524         snprintf(symboln, sizeof(symboln), "%sDrawArraysInstancedARB", symbol_prefix);
5525         *procp = dlsym(handle, symboln);
5526     }
5527
5528
5529     if(!disp->DrawArraysInstancedARB) {
5530         void ** procp = (void **) &disp->DrawArraysInstancedARB;
5531         snprintf(symboln, sizeof(symboln), "%sDrawArraysInstancedEXT", symbol_prefix);
5532         *procp = dlsym(handle, symboln);
5533     }
5534
5535
5536     if(!disp->DrawArraysInstancedARB) {
5537         void ** procp = (void **) &disp->DrawArraysInstancedARB;
5538         snprintf(symboln, sizeof(symboln), "%sDrawArraysInstanced", symbol_prefix);
5539         *procp = dlsym(handle, symboln);
5540     }
5541
5542
5543     if(!disp->DrawElementsInstancedARB) {
5544         void ** procp = (void **) &disp->DrawElementsInstancedARB;
5545         snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedARB", symbol_prefix);
5546         *procp = dlsym(handle, symboln);
5547     }
5548
5549
5550     if(!disp->DrawElementsInstancedARB) {
5551         void ** procp = (void **) &disp->DrawElementsInstancedARB;
5552         snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedEXT", symbol_prefix);
5553         *procp = dlsym(handle, symboln);
5554     }
5555
5556
5557     if(!disp->DrawElementsInstancedARB) {
5558         void ** procp = (void **) &disp->DrawElementsInstancedARB;
5559         snprintf(symboln, sizeof(symboln), "%sDrawElementsInstanced", symbol_prefix);
5560         *procp = dlsym(handle, symboln);
5561     }
5562
5563
5564     if(!disp->RenderbufferStorageMultisample) {
5565         void ** procp = (void **) &disp->RenderbufferStorageMultisample;
5566         snprintf(symboln, sizeof(symboln), "%sRenderbufferStorageMultisample", symbol_prefix);
5567         *procp = dlsym(handle, symboln);
5568     }
5569
5570
5571     if(!disp->RenderbufferStorageMultisample) {
5572         void ** procp = (void **) &disp->RenderbufferStorageMultisample;
5573         snprintf(symboln, sizeof(symboln), "%sRenderbufferStorageMultisampleEXT", symbol_prefix);
5574         *procp = dlsym(handle, symboln);
5575     }
5576
5577
5578     if(!disp->FramebufferTextureARB) {
5579         void ** procp = (void **) &disp->FramebufferTextureARB;
5580         snprintf(symboln, sizeof(symboln), "%sFramebufferTextureARB", symbol_prefix);
5581         *procp = dlsym(handle, symboln);
5582     }
5583
5584
5585     if(!disp->FramebufferTextureFaceARB) {
5586         void ** procp = (void **) &disp->FramebufferTextureFaceARB;
5587         snprintf(symboln, sizeof(symboln), "%sFramebufferTextureFaceARB", symbol_prefix);
5588         *procp = dlsym(handle, symboln);
5589     }
5590
5591
5592     if(!disp->ProgramParameteriARB) {
5593         void ** procp = (void **) &disp->ProgramParameteriARB;
5594         snprintf(symboln, sizeof(symboln), "%sProgramParameteriARB", symbol_prefix);
5595         *procp = dlsym(handle, symboln);
5596     }
5597
5598
5599     if(!disp->VertexAttribDivisorARB) {
5600         void ** procp = (void **) &disp->VertexAttribDivisorARB;
5601         snprintf(symboln, sizeof(symboln), "%sVertexAttribDivisorARB", symbol_prefix);
5602         *procp = dlsym(handle, symboln);
5603     }
5604
5605
5606     if(!disp->FlushMappedBufferRange) {
5607         void ** procp = (void **) &disp->FlushMappedBufferRange;
5608         snprintf(symboln, sizeof(symboln), "%sFlushMappedBufferRange", symbol_prefix);
5609         *procp = dlsym(handle, symboln);
5610     }
5611
5612
5613     if(!disp->MapBufferRange) {
5614         void ** procp = (void **) &disp->MapBufferRange;
5615         snprintf(symboln, sizeof(symboln), "%sMapBufferRange", symbol_prefix);
5616         *procp = dlsym(handle, symboln);
5617     }
5618
5619
5620     if(!disp->TexBufferARB) {
5621         void ** procp = (void **) &disp->TexBufferARB;
5622         snprintf(symboln, sizeof(symboln), "%sTexBufferARB", symbol_prefix);
5623         *procp = dlsym(handle, symboln);
5624     }
5625
5626
5627     if(!disp->BindVertexArray) {
5628         void ** procp = (void **) &disp->BindVertexArray;
5629         snprintf(symboln, sizeof(symboln), "%sBindVertexArray", symbol_prefix);
5630         *procp = dlsym(handle, symboln);
5631     }
5632
5633
5634     if(!disp->GenVertexArrays) {
5635         void ** procp = (void **) &disp->GenVertexArrays;
5636         snprintf(symboln, sizeof(symboln), "%sGenVertexArrays", symbol_prefix);
5637         *procp = dlsym(handle, symboln);
5638     }
5639
5640
5641     if(!disp->CopyBufferSubData) {
5642         void ** procp = (void **) &disp->CopyBufferSubData;
5643         snprintf(symboln, sizeof(symboln), "%sCopyBufferSubData", symbol_prefix);
5644         *procp = dlsym(handle, symboln);
5645     }
5646
5647
5648     if(!disp->ClientWaitSync) {
5649         void ** procp = (void **) &disp->ClientWaitSync;
5650         snprintf(symboln, sizeof(symboln), "%sClientWaitSync", symbol_prefix);
5651         *procp = dlsym(handle, symboln);
5652     }
5653
5654
5655     if(!disp->DeleteSync) {
5656         void ** procp = (void **) &disp->DeleteSync;
5657         snprintf(symboln, sizeof(symboln), "%sDeleteSync", symbol_prefix);
5658         *procp = dlsym(handle, symboln);
5659     }
5660
5661
5662     if(!disp->FenceSync) {
5663         void ** procp = (void **) &disp->FenceSync;
5664         snprintf(symboln, sizeof(symboln), "%sFenceSync", symbol_prefix);
5665         *procp = dlsym(handle, symboln);
5666     }
5667
5668
5669     if(!disp->GetInteger64v) {
5670         void ** procp = (void **) &disp->GetInteger64v;
5671         snprintf(symboln, sizeof(symboln), "%sGetInteger64v", symbol_prefix);
5672         *procp = dlsym(handle, symboln);
5673     }
5674
5675
5676     if(!disp->GetSynciv) {
5677         void ** procp = (void **) &disp->GetSynciv;
5678         snprintf(symboln, sizeof(symboln), "%sGetSynciv", symbol_prefix);
5679         *procp = dlsym(handle, symboln);
5680     }
5681
5682
5683     if(!disp->IsSync) {
5684         void ** procp = (void **) &disp->IsSync;
5685         snprintf(symboln, sizeof(symboln), "%sIsSync", symbol_prefix);
5686         *procp = dlsym(handle, symboln);
5687     }
5688
5689
5690     if(!disp->WaitSync) {
5691         void ** procp = (void **) &disp->WaitSync;
5692         snprintf(symboln, sizeof(symboln), "%sWaitSync", symbol_prefix);
5693         *procp = dlsym(handle, symboln);
5694     }
5695
5696
5697     if(!disp->DrawElementsBaseVertex) {
5698         void ** procp = (void **) &disp->DrawElementsBaseVertex;
5699         snprintf(symboln, sizeof(symboln), "%sDrawElementsBaseVertex", symbol_prefix);
5700         *procp = dlsym(handle, symboln);
5701     }
5702
5703
5704     if(!disp->DrawElementsInstancedBaseVertex) {
5705         void ** procp = (void **) &disp->DrawElementsInstancedBaseVertex;
5706         snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedBaseVertex", symbol_prefix);
5707         *procp = dlsym(handle, symboln);
5708     }
5709
5710
5711     if(!disp->DrawRangeElementsBaseVertex) {
5712         void ** procp = (void **) &disp->DrawRangeElementsBaseVertex;
5713         snprintf(symboln, sizeof(symboln), "%sDrawRangeElementsBaseVertex", symbol_prefix);
5714         *procp = dlsym(handle, symboln);
5715     }
5716
5717
5718     if(!disp->MultiDrawElementsBaseVertex) {
5719         void ** procp = (void **) &disp->MultiDrawElementsBaseVertex;
5720         snprintf(symboln, sizeof(symboln), "%sMultiDrawElementsBaseVertex", symbol_prefix);
5721         *procp = dlsym(handle, symboln);
5722     }
5723
5724
5725     if(!disp->BlendEquationSeparateiARB) {
5726         void ** procp = (void **) &disp->BlendEquationSeparateiARB;
5727         snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateiARB", symbol_prefix);
5728         *procp = dlsym(handle, symboln);
5729     }
5730
5731
5732     if(!disp->BlendEquationSeparateiARB) {
5733         void ** procp = (void **) &disp->BlendEquationSeparateiARB;
5734         snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateIndexedAMD", symbol_prefix);
5735         *procp = dlsym(handle, symboln);
5736     }
5737
5738
5739     if(!disp->BlendEquationiARB) {
5740         void ** procp = (void **) &disp->BlendEquationiARB;
5741         snprintf(symboln, sizeof(symboln), "%sBlendEquationiARB", symbol_prefix);
5742         *procp = dlsym(handle, symboln);
5743     }
5744
5745
5746     if(!disp->BlendEquationiARB) {
5747         void ** procp = (void **) &disp->BlendEquationiARB;
5748         snprintf(symboln, sizeof(symboln), "%sBlendEquationIndexedAMD", symbol_prefix);
5749         *procp = dlsym(handle, symboln);
5750     }
5751
5752
5753     if(!disp->BlendFuncSeparateiARB) {
5754         void ** procp = (void **) &disp->BlendFuncSeparateiARB;
5755         snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateiARB", symbol_prefix);
5756         *procp = dlsym(handle, symboln);
5757     }
5758
5759
5760     if(!disp->BlendFuncSeparateiARB) {
5761         void ** procp = (void **) &disp->BlendFuncSeparateiARB;
5762         snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateIndexedAMD", symbol_prefix);
5763         *procp = dlsym(handle, symboln);
5764     }
5765
5766
5767     if(!disp->BlendFunciARB) {
5768         void ** procp = (void **) &disp->BlendFunciARB;
5769         snprintf(symboln, sizeof(symboln), "%sBlendFunciARB", symbol_prefix);
5770         *procp = dlsym(handle, symboln);
5771     }
5772
5773
5774     if(!disp->BlendFunciARB) {
5775         void ** procp = (void **) &disp->BlendFunciARB;
5776         snprintf(symboln, sizeof(symboln), "%sBlendFuncIndexedAMD", symbol_prefix);
5777         *procp = dlsym(handle, symboln);
5778     }
5779
5780
5781     if(!disp->BindSampler) {
5782         void ** procp = (void **) &disp->BindSampler;
5783         snprintf(symboln, sizeof(symboln), "%sBindSampler", symbol_prefix);
5784         *procp = dlsym(handle, symboln);
5785     }
5786
5787
5788     if(!disp->DeleteSamplers) {
5789         void ** procp = (void **) &disp->DeleteSamplers;
5790         snprintf(symboln, sizeof(symboln), "%sDeleteSamplers", symbol_prefix);
5791         *procp = dlsym(handle, symboln);
5792     }
5793
5794
5795     if(!disp->GenSamplers) {
5796         void ** procp = (void **) &disp->GenSamplers;
5797         snprintf(symboln, sizeof(symboln), "%sGenSamplers", symbol_prefix);
5798         *procp = dlsym(handle, symboln);
5799     }
5800
5801
5802     if(!disp->GetSamplerParameterIiv) {
5803         void ** procp = (void **) &disp->GetSamplerParameterIiv;
5804         snprintf(symboln, sizeof(symboln), "%sGetSamplerParameterIiv", symbol_prefix);
5805         *procp = dlsym(handle, symboln);
5806     }
5807
5808
5809     if(!disp->GetSamplerParameterIuiv) {
5810         void ** procp = (void **) &disp->GetSamplerParameterIuiv;
5811         snprintf(symboln, sizeof(symboln), "%sGetSamplerParameterIuiv", symbol_prefix);
5812         *procp = dlsym(handle, symboln);
5813     }
5814
5815
5816     if(!disp->GetSamplerParameterfv) {
5817         void ** procp = (void **) &disp->GetSamplerParameterfv;
5818         snprintf(symboln, sizeof(symboln), "%sGetSamplerParameterfv", symbol_prefix);
5819         *procp = dlsym(handle, symboln);
5820     }
5821
5822
5823     if(!disp->GetSamplerParameteriv) {
5824         void ** procp = (void **) &disp->GetSamplerParameteriv;
5825         snprintf(symboln, sizeof(symboln), "%sGetSamplerParameteriv", symbol_prefix);
5826         *procp = dlsym(handle, symboln);
5827     }
5828
5829
5830     if(!disp->IsSampler) {
5831         void ** procp = (void **) &disp->IsSampler;
5832         snprintf(symboln, sizeof(symboln), "%sIsSampler", symbol_prefix);
5833         *procp = dlsym(handle, symboln);
5834     }
5835
5836
5837     if(!disp->SamplerParameterIiv) {
5838         void ** procp = (void **) &disp->SamplerParameterIiv;
5839         snprintf(symboln, sizeof(symboln), "%sSamplerParameterIiv", symbol_prefix);
5840         *procp = dlsym(handle, symboln);
5841     }
5842
5843
5844     if(!disp->SamplerParameterIuiv) {
5845         void ** procp = (void **) &disp->SamplerParameterIuiv;
5846         snprintf(symboln, sizeof(symboln), "%sSamplerParameterIuiv", symbol_prefix);
5847         *procp = dlsym(handle, symboln);
5848     }
5849
5850
5851     if(!disp->SamplerParameterf) {
5852         void ** procp = (void **) &disp->SamplerParameterf;
5853         snprintf(symboln, sizeof(symboln), "%sSamplerParameterf", symbol_prefix);
5854         *procp = dlsym(handle, symboln);
5855     }
5856
5857
5858     if(!disp->SamplerParameterfv) {
5859         void ** procp = (void **) &disp->SamplerParameterfv;
5860         snprintf(symboln, sizeof(symboln), "%sSamplerParameterfv", symbol_prefix);
5861         *procp = dlsym(handle, symboln);
5862     }
5863
5864
5865     if(!disp->SamplerParameteri) {
5866         void ** procp = (void **) &disp->SamplerParameteri;
5867         snprintf(symboln, sizeof(symboln), "%sSamplerParameteri", symbol_prefix);
5868         *procp = dlsym(handle, symboln);
5869     }
5870
5871
5872     if(!disp->SamplerParameteriv) {
5873         void ** procp = (void **) &disp->SamplerParameteriv;
5874         snprintf(symboln, sizeof(symboln), "%sSamplerParameteriv", symbol_prefix);
5875         *procp = dlsym(handle, symboln);
5876     }
5877
5878
5879     if(!disp->BindTransformFeedback) {
5880         void ** procp = (void **) &disp->BindTransformFeedback;
5881         snprintf(symboln, sizeof(symboln), "%sBindTransformFeedback", symbol_prefix);
5882         *procp = dlsym(handle, symboln);
5883     }
5884
5885
5886     if(!disp->DeleteTransformFeedbacks) {
5887         void ** procp = (void **) &disp->DeleteTransformFeedbacks;
5888         snprintf(symboln, sizeof(symboln), "%sDeleteTransformFeedbacks", symbol_prefix);
5889         *procp = dlsym(handle, symboln);
5890     }
5891
5892
5893     if(!disp->DrawTransformFeedback) {
5894         void ** procp = (void **) &disp->DrawTransformFeedback;
5895         snprintf(symboln, sizeof(symboln), "%sDrawTransformFeedback", symbol_prefix);
5896         *procp = dlsym(handle, symboln);
5897     }
5898
5899
5900     if(!disp->GenTransformFeedbacks) {
5901         void ** procp = (void **) &disp->GenTransformFeedbacks;
5902         snprintf(symboln, sizeof(symboln), "%sGenTransformFeedbacks", symbol_prefix);
5903         *procp = dlsym(handle, symboln);
5904     }
5905
5906
5907     if(!disp->IsTransformFeedback) {
5908         void ** procp = (void **) &disp->IsTransformFeedback;
5909         snprintf(symboln, sizeof(symboln), "%sIsTransformFeedback", symbol_prefix);
5910         *procp = dlsym(handle, symboln);
5911     }
5912
5913
5914     if(!disp->PauseTransformFeedback) {
5915         void ** procp = (void **) &disp->PauseTransformFeedback;
5916         snprintf(symboln, sizeof(symboln), "%sPauseTransformFeedback", symbol_prefix);
5917         *procp = dlsym(handle, symboln);
5918     }
5919
5920
5921     if(!disp->ResumeTransformFeedback) {
5922         void ** procp = (void **) &disp->ResumeTransformFeedback;
5923         snprintf(symboln, sizeof(symboln), "%sResumeTransformFeedback", symbol_prefix);
5924         *procp = dlsym(handle, symboln);
5925     }
5926
5927
5928     if(!disp->ClearDepthf) {
5929         void ** procp = (void **) &disp->ClearDepthf;
5930         snprintf(symboln, sizeof(symboln), "%sClearDepthf", symbol_prefix);
5931         *procp = dlsym(handle, symboln);
5932     }
5933
5934
5935     if(!disp->DepthRangef) {
5936         void ** procp = (void **) &disp->DepthRangef;
5937         snprintf(symboln, sizeof(symboln), "%sDepthRangef", symbol_prefix);
5938         *procp = dlsym(handle, symboln);
5939     }
5940
5941
5942     if(!disp->GetShaderPrecisionFormat) {
5943         void ** procp = (void **) &disp->GetShaderPrecisionFormat;
5944         snprintf(symboln, sizeof(symboln), "%sGetShaderPrecisionFormat", symbol_prefix);
5945         *procp = dlsym(handle, symboln);
5946     }
5947
5948
5949     if(!disp->ReleaseShaderCompiler) {
5950         void ** procp = (void **) &disp->ReleaseShaderCompiler;
5951         snprintf(symboln, sizeof(symboln), "%sReleaseShaderCompiler", symbol_prefix);
5952         *procp = dlsym(handle, symboln);
5953     }
5954
5955
5956     if(!disp->ShaderBinary) {
5957         void ** procp = (void **) &disp->ShaderBinary;
5958         snprintf(symboln, sizeof(symboln), "%sShaderBinary", symbol_prefix);
5959         *procp = dlsym(handle, symboln);
5960     }
5961
5962
5963     if(!disp->GetGraphicsResetStatusARB) {
5964         void ** procp = (void **) &disp->GetGraphicsResetStatusARB;
5965         snprintf(symboln, sizeof(symboln), "%sGetGraphicsResetStatusARB", symbol_prefix);
5966         *procp = dlsym(handle, symboln);
5967     }
5968
5969
5970     if(!disp->GetnColorTableARB) {
5971         void ** procp = (void **) &disp->GetnColorTableARB;
5972         snprintf(symboln, sizeof(symboln), "%sGetnColorTableARB", symbol_prefix);
5973         *procp = dlsym(handle, symboln);
5974     }
5975
5976
5977     if(!disp->GetnCompressedTexImageARB) {
5978         void ** procp = (void **) &disp->GetnCompressedTexImageARB;
5979         snprintf(symboln, sizeof(symboln), "%sGetnCompressedTexImageARB", symbol_prefix);
5980         *procp = dlsym(handle, symboln);
5981     }
5982
5983
5984     if(!disp->GetnConvolutionFilterARB) {
5985         void ** procp = (void **) &disp->GetnConvolutionFilterARB;
5986         snprintf(symboln, sizeof(symboln), "%sGetnConvolutionFilterARB", symbol_prefix);
5987         *procp = dlsym(handle, symboln);
5988     }
5989
5990
5991     if(!disp->GetnHistogramARB) {
5992         void ** procp = (void **) &disp->GetnHistogramARB;
5993         snprintf(symboln, sizeof(symboln), "%sGetnHistogramARB", symbol_prefix);
5994         *procp = dlsym(handle, symboln);
5995     }
5996
5997
5998     if(!disp->GetnMapdvARB) {
5999         void ** procp = (void **) &disp->GetnMapdvARB;
6000         snprintf(symboln, sizeof(symboln), "%sGetnMapdvARB", symbol_prefix);
6001         *procp = dlsym(handle, symboln);
6002     }
6003
6004
6005     if(!disp->GetnMapfvARB) {
6006         void ** procp = (void **) &disp->GetnMapfvARB;
6007         snprintf(symboln, sizeof(symboln), "%sGetnMapfvARB", symbol_prefix);
6008         *procp = dlsym(handle, symboln);
6009     }
6010
6011
6012     if(!disp->GetnMapivARB) {
6013         void ** procp = (void **) &disp->GetnMapivARB;
6014         snprintf(symboln, sizeof(symboln), "%sGetnMapivARB", symbol_prefix);
6015         *procp = dlsym(handle, symboln);
6016     }
6017
6018
6019     if(!disp->GetnMinmaxARB) {
6020         void ** procp = (void **) &disp->GetnMinmaxARB;
6021         snprintf(symboln, sizeof(symboln), "%sGetnMinmaxARB", symbol_prefix);
6022         *procp = dlsym(handle, symboln);
6023     }
6024
6025
6026     if(!disp->GetnPixelMapfvARB) {
6027         void ** procp = (void **) &disp->GetnPixelMapfvARB;
6028         snprintf(symboln, sizeof(symboln), "%sGetnPixelMapfvARB", symbol_prefix);
6029         *procp = dlsym(handle, symboln);
6030     }
6031
6032
6033     if(!disp->GetnPixelMapuivARB) {
6034         void ** procp = (void **) &disp->GetnPixelMapuivARB;
6035         snprintf(symboln, sizeof(symboln), "%sGetnPixelMapuivARB", symbol_prefix);
6036         *procp = dlsym(handle, symboln);
6037     }
6038
6039
6040     if(!disp->GetnPixelMapusvARB) {
6041         void ** procp = (void **) &disp->GetnPixelMapusvARB;
6042         snprintf(symboln, sizeof(symboln), "%sGetnPixelMapusvARB", symbol_prefix);
6043         *procp = dlsym(handle, symboln);
6044     }
6045
6046
6047     if(!disp->GetnPolygonStippleARB) {
6048         void ** procp = (void **) &disp->GetnPolygonStippleARB;
6049         snprintf(symboln, sizeof(symboln), "%sGetnPolygonStippleARB", symbol_prefix);
6050         *procp = dlsym(handle, symboln);
6051     }
6052
6053
6054     if(!disp->GetnSeparableFilterARB) {
6055         void ** procp = (void **) &disp->GetnSeparableFilterARB;
6056         snprintf(symboln, sizeof(symboln), "%sGetnSeparableFilterARB", symbol_prefix);
6057         *procp = dlsym(handle, symboln);
6058     }
6059
6060
6061     if(!disp->GetnTexImageARB) {
6062         void ** procp = (void **) &disp->GetnTexImageARB;
6063         snprintf(symboln, sizeof(symboln), "%sGetnTexImageARB", symbol_prefix);
6064         *procp = dlsym(handle, symboln);
6065     }
6066
6067
6068     if(!disp->GetnUniformdvARB) {
6069         void ** procp = (void **) &disp->GetnUniformdvARB;
6070         snprintf(symboln, sizeof(symboln), "%sGetnUniformdvARB", symbol_prefix);
6071         *procp = dlsym(handle, symboln);
6072     }
6073
6074
6075     if(!disp->GetnUniformfvARB) {
6076         void ** procp = (void **) &disp->GetnUniformfvARB;
6077         snprintf(symboln, sizeof(symboln), "%sGetnUniformfvARB", symbol_prefix);
6078         *procp = dlsym(handle, symboln);
6079     }
6080
6081
6082     if(!disp->GetnUniformivARB) {
6083         void ** procp = (void **) &disp->GetnUniformivARB;
6084         snprintf(symboln, sizeof(symboln), "%sGetnUniformivARB", symbol_prefix);
6085         *procp = dlsym(handle, symboln);
6086     }
6087
6088
6089     if(!disp->GetnUniformuivARB) {
6090         void ** procp = (void **) &disp->GetnUniformuivARB;
6091         snprintf(symboln, sizeof(symboln), "%sGetnUniformuivARB", symbol_prefix);
6092         *procp = dlsym(handle, symboln);
6093     }
6094
6095
6096     if(!disp->ReadnPixelsARB) {
6097         void ** procp = (void **) &disp->ReadnPixelsARB;
6098         snprintf(symboln, sizeof(symboln), "%sReadnPixelsARB", symbol_prefix);
6099         *procp = dlsym(handle, symboln);
6100     }
6101
6102
6103     if(!disp->PolygonOffsetEXT) {
6104         void ** procp = (void **) &disp->PolygonOffsetEXT;
6105         snprintf(symboln, sizeof(symboln), "%sPolygonOffsetEXT", symbol_prefix);
6106         *procp = dlsym(handle, symboln);
6107     }
6108
6109
6110     if(!disp->GetPixelTexGenParameterfvSGIS) {
6111         void ** procp = (void **) &disp->GetPixelTexGenParameterfvSGIS;
6112         snprintf(symboln, sizeof(symboln), "%sGetPixelTexGenParameterfvSGIS", symbol_prefix);
6113         *procp = dlsym(handle, symboln);
6114     }
6115
6116
6117     if(!disp->GetPixelTexGenParameterivSGIS) {
6118         void ** procp = (void **) &disp->GetPixelTexGenParameterivSGIS;
6119         snprintf(symboln, sizeof(symboln), "%sGetPixelTexGenParameterivSGIS", symbol_prefix);
6120         *procp = dlsym(handle, symboln);
6121     }
6122
6123
6124     if(!disp->PixelTexGenParameterfSGIS) {
6125         void ** procp = (void **) &disp->PixelTexGenParameterfSGIS;
6126         snprintf(symboln, sizeof(symboln), "%sPixelTexGenParameterfSGIS", symbol_prefix);
6127         *procp = dlsym(handle, symboln);
6128     }
6129
6130
6131     if(!disp->PixelTexGenParameterfvSGIS) {
6132         void ** procp = (void **) &disp->PixelTexGenParameterfvSGIS;
6133         snprintf(symboln, sizeof(symboln), "%sPixelTexGenParameterfvSGIS", symbol_prefix);
6134         *procp = dlsym(handle, symboln);
6135     }
6136
6137
6138     if(!disp->PixelTexGenParameteriSGIS) {
6139         void ** procp = (void **) &disp->PixelTexGenParameteriSGIS;
6140         snprintf(symboln, sizeof(symboln), "%sPixelTexGenParameteriSGIS", symbol_prefix);
6141         *procp = dlsym(handle, symboln);
6142     }
6143
6144
6145     if(!disp->PixelTexGenParameterivSGIS) {
6146         void ** procp = (void **) &disp->PixelTexGenParameterivSGIS;
6147         snprintf(symboln, sizeof(symboln), "%sPixelTexGenParameterivSGIS", symbol_prefix);
6148         *procp = dlsym(handle, symboln);
6149     }
6150
6151
6152     if(!disp->SampleMaskSGIS) {
6153         void ** procp = (void **) &disp->SampleMaskSGIS;
6154         snprintf(symboln, sizeof(symboln), "%sSampleMaskSGIS", symbol_prefix);
6155         *procp = dlsym(handle, symboln);
6156     }
6157
6158
6159     if(!disp->SampleMaskSGIS) {
6160         void ** procp = (void **) &disp->SampleMaskSGIS;
6161         snprintf(symboln, sizeof(symboln), "%sSampleMaskEXT", symbol_prefix);
6162         *procp = dlsym(handle, symboln);
6163     }
6164
6165
6166     if(!disp->SamplePatternSGIS) {
6167         void ** procp = (void **) &disp->SamplePatternSGIS;
6168         snprintf(symboln, sizeof(symboln), "%sSamplePatternSGIS", symbol_prefix);
6169         *procp = dlsym(handle, symboln);
6170     }
6171
6172
6173     if(!disp->SamplePatternSGIS) {
6174         void ** procp = (void **) &disp->SamplePatternSGIS;
6175         snprintf(symboln, sizeof(symboln), "%sSamplePatternEXT", symbol_prefix);
6176         *procp = dlsym(handle, symboln);
6177     }
6178
6179
6180     if(!disp->ColorPointerEXT) {
6181         void ** procp = (void **) &disp->ColorPointerEXT;
6182         snprintf(symboln, sizeof(symboln), "%sColorPointerEXT", symbol_prefix);
6183         *procp = dlsym(handle, symboln);
6184     }
6185
6186
6187     if(!disp->EdgeFlagPointerEXT) {
6188         void ** procp = (void **) &disp->EdgeFlagPointerEXT;
6189         snprintf(symboln, sizeof(symboln), "%sEdgeFlagPointerEXT", symbol_prefix);
6190         *procp = dlsym(handle, symboln);
6191     }
6192
6193
6194     if(!disp->IndexPointerEXT) {
6195         void ** procp = (void **) &disp->IndexPointerEXT;
6196         snprintf(symboln, sizeof(symboln), "%sIndexPointerEXT", symbol_prefix);
6197         *procp = dlsym(handle, symboln);
6198     }
6199
6200
6201     if(!disp->NormalPointerEXT) {
6202         void ** procp = (void **) &disp->NormalPointerEXT;
6203         snprintf(symboln, sizeof(symboln), "%sNormalPointerEXT", symbol_prefix);
6204         *procp = dlsym(handle, symboln);
6205     }
6206
6207
6208     if(!disp->TexCoordPointerEXT) {
6209         void ** procp = (void **) &disp->TexCoordPointerEXT;
6210         snprintf(symboln, sizeof(symboln), "%sTexCoordPointerEXT", symbol_prefix);
6211         *procp = dlsym(handle, symboln);
6212     }
6213
6214
6215     if(!disp->VertexPointerEXT) {
6216         void ** procp = (void **) &disp->VertexPointerEXT;
6217         snprintf(symboln, sizeof(symboln), "%sVertexPointerEXT", symbol_prefix);
6218         *procp = dlsym(handle, symboln);
6219     }
6220
6221
6222     if(!disp->PointParameterfEXT) {
6223         void ** procp = (void **) &disp->PointParameterfEXT;
6224         snprintf(symboln, sizeof(symboln), "%sPointParameterf", symbol_prefix);
6225         *procp = dlsym(handle, symboln);
6226     }
6227
6228
6229     if(!disp->PointParameterfEXT) {
6230         void ** procp = (void **) &disp->PointParameterfEXT;
6231         snprintf(symboln, sizeof(symboln), "%sPointParameterfARB", symbol_prefix);
6232         *procp = dlsym(handle, symboln);
6233     }
6234
6235
6236     if(!disp->PointParameterfEXT) {
6237         void ** procp = (void **) &disp->PointParameterfEXT;
6238         snprintf(symboln, sizeof(symboln), "%sPointParameterfEXT", symbol_prefix);
6239         *procp = dlsym(handle, symboln);
6240     }
6241
6242
6243     if(!disp->PointParameterfEXT) {
6244         void ** procp = (void **) &disp->PointParameterfEXT;
6245         snprintf(symboln, sizeof(symboln), "%sPointParameterfSGIS", symbol_prefix);
6246         *procp = dlsym(handle, symboln);
6247     }
6248
6249
6250     if(!disp->PointParameterfvEXT) {
6251         void ** procp = (void **) &disp->PointParameterfvEXT;
6252         snprintf(symboln, sizeof(symboln), "%sPointParameterfv", symbol_prefix);
6253         *procp = dlsym(handle, symboln);
6254     }
6255
6256
6257     if(!disp->PointParameterfvEXT) {
6258         void ** procp = (void **) &disp->PointParameterfvEXT;
6259         snprintf(symboln, sizeof(symboln), "%sPointParameterfvARB", symbol_prefix);
6260         *procp = dlsym(handle, symboln);
6261     }
6262
6263
6264     if(!disp->PointParameterfvEXT) {
6265         void ** procp = (void **) &disp->PointParameterfvEXT;
6266         snprintf(symboln, sizeof(symboln), "%sPointParameterfvEXT", symbol_prefix);
6267         *procp = dlsym(handle, symboln);
6268     }
6269
6270
6271     if(!disp->PointParameterfvEXT) {
6272         void ** procp = (void **) &disp->PointParameterfvEXT;
6273         snprintf(symboln, sizeof(symboln), "%sPointParameterfvSGIS", symbol_prefix);
6274         *procp = dlsym(handle, symboln);
6275     }
6276
6277
6278     if(!disp->LockArraysEXT) {
6279         void ** procp = (void **) &disp->LockArraysEXT;
6280         snprintf(symboln, sizeof(symboln), "%sLockArraysEXT", symbol_prefix);
6281         *procp = dlsym(handle, symboln);
6282     }
6283
6284
6285     if(!disp->UnlockArraysEXT) {
6286         void ** procp = (void **) &disp->UnlockArraysEXT;
6287         snprintf(symboln, sizeof(symboln), "%sUnlockArraysEXT", symbol_prefix);
6288         *procp = dlsym(handle, symboln);
6289     }
6290
6291
6292     if(!disp->SecondaryColor3bEXT) {
6293         void ** procp = (void **) &disp->SecondaryColor3bEXT;
6294         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3b", symbol_prefix);
6295         *procp = dlsym(handle, symboln);
6296     }
6297
6298
6299     if(!disp->SecondaryColor3bEXT) {
6300         void ** procp = (void **) &disp->SecondaryColor3bEXT;
6301         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3bEXT", symbol_prefix);
6302         *procp = dlsym(handle, symboln);
6303     }
6304
6305
6306     if(!disp->SecondaryColor3bvEXT) {
6307         void ** procp = (void **) &disp->SecondaryColor3bvEXT;
6308         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3bv", symbol_prefix);
6309         *procp = dlsym(handle, symboln);
6310     }
6311
6312
6313     if(!disp->SecondaryColor3bvEXT) {
6314         void ** procp = (void **) &disp->SecondaryColor3bvEXT;
6315         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3bvEXT", symbol_prefix);
6316         *procp = dlsym(handle, symboln);
6317     }
6318
6319
6320     if(!disp->SecondaryColor3dEXT) {
6321         void ** procp = (void **) &disp->SecondaryColor3dEXT;
6322         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3d", symbol_prefix);
6323         *procp = dlsym(handle, symboln);
6324     }
6325
6326
6327     if(!disp->SecondaryColor3dEXT) {
6328         void ** procp = (void **) &disp->SecondaryColor3dEXT;
6329         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3dEXT", symbol_prefix);
6330         *procp = dlsym(handle, symboln);
6331     }
6332
6333
6334     if(!disp->SecondaryColor3dvEXT) {
6335         void ** procp = (void **) &disp->SecondaryColor3dvEXT;
6336         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3dv", symbol_prefix);
6337         *procp = dlsym(handle, symboln);
6338     }
6339
6340
6341     if(!disp->SecondaryColor3dvEXT) {
6342         void ** procp = (void **) &disp->SecondaryColor3dvEXT;
6343         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3dvEXT", symbol_prefix);
6344         *procp = dlsym(handle, symboln);
6345     }
6346
6347
6348     if(!disp->SecondaryColor3fEXT) {
6349         void ** procp = (void **) &disp->SecondaryColor3fEXT;
6350         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3f", symbol_prefix);
6351         *procp = dlsym(handle, symboln);
6352     }
6353
6354
6355     if(!disp->SecondaryColor3fEXT) {
6356         void ** procp = (void **) &disp->SecondaryColor3fEXT;
6357         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3fEXT", symbol_prefix);
6358         *procp = dlsym(handle, symboln);
6359     }
6360
6361
6362     if(!disp->SecondaryColor3fvEXT) {
6363         void ** procp = (void **) &disp->SecondaryColor3fvEXT;
6364         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3fv", symbol_prefix);
6365         *procp = dlsym(handle, symboln);
6366     }
6367
6368
6369     if(!disp->SecondaryColor3fvEXT) {
6370         void ** procp = (void **) &disp->SecondaryColor3fvEXT;
6371         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3fvEXT", symbol_prefix);
6372         *procp = dlsym(handle, symboln);
6373     }
6374
6375
6376     if(!disp->SecondaryColor3iEXT) {
6377         void ** procp = (void **) &disp->SecondaryColor3iEXT;
6378         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3i", symbol_prefix);
6379         *procp = dlsym(handle, symboln);
6380     }
6381
6382
6383     if(!disp->SecondaryColor3iEXT) {
6384         void ** procp = (void **) &disp->SecondaryColor3iEXT;
6385         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3iEXT", symbol_prefix);
6386         *procp = dlsym(handle, symboln);
6387     }
6388
6389
6390     if(!disp->SecondaryColor3ivEXT) {
6391         void ** procp = (void **) &disp->SecondaryColor3ivEXT;
6392         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3iv", symbol_prefix);
6393         *procp = dlsym(handle, symboln);
6394     }
6395
6396
6397     if(!disp->SecondaryColor3ivEXT) {
6398         void ** procp = (void **) &disp->SecondaryColor3ivEXT;
6399         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ivEXT", symbol_prefix);
6400         *procp = dlsym(handle, symboln);
6401     }
6402
6403
6404     if(!disp->SecondaryColor3sEXT) {
6405         void ** procp = (void **) &disp->SecondaryColor3sEXT;
6406         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3s", symbol_prefix);
6407         *procp = dlsym(handle, symboln);
6408     }
6409
6410
6411     if(!disp->SecondaryColor3sEXT) {
6412         void ** procp = (void **) &disp->SecondaryColor3sEXT;
6413         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3sEXT", symbol_prefix);
6414         *procp = dlsym(handle, symboln);
6415     }
6416
6417
6418     if(!disp->SecondaryColor3svEXT) {
6419         void ** procp = (void **) &disp->SecondaryColor3svEXT;
6420         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3sv", symbol_prefix);
6421         *procp = dlsym(handle, symboln);
6422     }
6423
6424
6425     if(!disp->SecondaryColor3svEXT) {
6426         void ** procp = (void **) &disp->SecondaryColor3svEXT;
6427         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3svEXT", symbol_prefix);
6428         *procp = dlsym(handle, symboln);
6429     }
6430
6431
6432     if(!disp->SecondaryColor3ubEXT) {
6433         void ** procp = (void **) &disp->SecondaryColor3ubEXT;
6434         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ub", symbol_prefix);
6435         *procp = dlsym(handle, symboln);
6436     }
6437
6438
6439     if(!disp->SecondaryColor3ubEXT) {
6440         void ** procp = (void **) &disp->SecondaryColor3ubEXT;
6441         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ubEXT", symbol_prefix);
6442         *procp = dlsym(handle, symboln);
6443     }
6444
6445
6446     if(!disp->SecondaryColor3ubvEXT) {
6447         void ** procp = (void **) &disp->SecondaryColor3ubvEXT;
6448         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ubv", symbol_prefix);
6449         *procp = dlsym(handle, symboln);
6450     }
6451
6452
6453     if(!disp->SecondaryColor3ubvEXT) {
6454         void ** procp = (void **) &disp->SecondaryColor3ubvEXT;
6455         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ubvEXT", symbol_prefix);
6456         *procp = dlsym(handle, symboln);
6457     }
6458
6459
6460     if(!disp->SecondaryColor3uiEXT) {
6461         void ** procp = (void **) &disp->SecondaryColor3uiEXT;
6462         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ui", symbol_prefix);
6463         *procp = dlsym(handle, symboln);
6464     }
6465
6466
6467     if(!disp->SecondaryColor3uiEXT) {
6468         void ** procp = (void **) &disp->SecondaryColor3uiEXT;
6469         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3uiEXT", symbol_prefix);
6470         *procp = dlsym(handle, symboln);
6471     }
6472
6473
6474     if(!disp->SecondaryColor3uivEXT) {
6475         void ** procp = (void **) &disp->SecondaryColor3uivEXT;
6476         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3uiv", symbol_prefix);
6477         *procp = dlsym(handle, symboln);
6478     }
6479
6480
6481     if(!disp->SecondaryColor3uivEXT) {
6482         void ** procp = (void **) &disp->SecondaryColor3uivEXT;
6483         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3uivEXT", symbol_prefix);
6484         *procp = dlsym(handle, symboln);
6485     }
6486
6487
6488     if(!disp->SecondaryColor3usEXT) {
6489         void ** procp = (void **) &disp->SecondaryColor3usEXT;
6490         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3us", symbol_prefix);
6491         *procp = dlsym(handle, symboln);
6492     }
6493
6494
6495     if(!disp->SecondaryColor3usEXT) {
6496         void ** procp = (void **) &disp->SecondaryColor3usEXT;
6497         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3usEXT", symbol_prefix);
6498         *procp = dlsym(handle, symboln);
6499     }
6500
6501
6502     if(!disp->SecondaryColor3usvEXT) {
6503         void ** procp = (void **) &disp->SecondaryColor3usvEXT;
6504         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3usv", symbol_prefix);
6505         *procp = dlsym(handle, symboln);
6506     }
6507
6508
6509     if(!disp->SecondaryColor3usvEXT) {
6510         void ** procp = (void **) &disp->SecondaryColor3usvEXT;
6511         snprintf(symboln, sizeof(symboln), "%sSecondaryColor3usvEXT", symbol_prefix);
6512         *procp = dlsym(handle, symboln);
6513     }
6514
6515
6516     if(!disp->SecondaryColorPointerEXT) {
6517         void ** procp = (void **) &disp->SecondaryColorPointerEXT;
6518         snprintf(symboln, sizeof(symboln), "%sSecondaryColorPointer", symbol_prefix);
6519         *procp = dlsym(handle, symboln);
6520     }
6521
6522
6523     if(!disp->SecondaryColorPointerEXT) {
6524         void ** procp = (void **) &disp->SecondaryColorPointerEXT;
6525         snprintf(symboln, sizeof(symboln), "%sSecondaryColorPointerEXT", symbol_prefix);
6526         *procp = dlsym(handle, symboln);
6527     }
6528
6529
6530     if(!disp->MultiDrawArraysEXT) {
6531         void ** procp = (void **) &disp->MultiDrawArraysEXT;
6532         snprintf(symboln, sizeof(symboln), "%sMultiDrawArrays", symbol_prefix);
6533         *procp = dlsym(handle, symboln);
6534     }
6535
6536
6537     if(!disp->MultiDrawArraysEXT) {
6538         void ** procp = (void **) &disp->MultiDrawArraysEXT;
6539         snprintf(symboln, sizeof(symboln), "%sMultiDrawArraysEXT", symbol_prefix);
6540         *procp = dlsym(handle, symboln);
6541     }
6542
6543
6544     if(!disp->MultiDrawElementsEXT) {
6545         void ** procp = (void **) &disp->MultiDrawElementsEXT;
6546         snprintf(symboln, sizeof(symboln), "%sMultiDrawElements", symbol_prefix);
6547         *procp = dlsym(handle, symboln);
6548     }
6549
6550
6551     if(!disp->MultiDrawElementsEXT) {
6552         void ** procp = (void **) &disp->MultiDrawElementsEXT;
6553         snprintf(symboln, sizeof(symboln), "%sMultiDrawElementsEXT", symbol_prefix);
6554         *procp = dlsym(handle, symboln);
6555     }
6556
6557
6558     if(!disp->FogCoordPointerEXT) {
6559         void ** procp = (void **) &disp->FogCoordPointerEXT;
6560         snprintf(symboln, sizeof(symboln), "%sFogCoordPointer", symbol_prefix);
6561         *procp = dlsym(handle, symboln);
6562     }
6563
6564
6565     if(!disp->FogCoordPointerEXT) {
6566         void ** procp = (void **) &disp->FogCoordPointerEXT;
6567         snprintf(symboln, sizeof(symboln), "%sFogCoordPointerEXT", symbol_prefix);
6568         *procp = dlsym(handle, symboln);
6569     }
6570
6571
6572     if(!disp->FogCoorddEXT) {
6573         void ** procp = (void **) &disp->FogCoorddEXT;
6574         snprintf(symboln, sizeof(symboln), "%sFogCoordd", symbol_prefix);
6575         *procp = dlsym(handle, symboln);
6576     }
6577
6578
6579     if(!disp->FogCoorddEXT) {
6580         void ** procp = (void **) &disp->FogCoorddEXT;
6581         snprintf(symboln, sizeof(symboln), "%sFogCoorddEXT", symbol_prefix);
6582         *procp = dlsym(handle, symboln);
6583     }
6584
6585
6586     if(!disp->FogCoorddvEXT) {
6587         void ** procp = (void **) &disp->FogCoorddvEXT;
6588         snprintf(symboln, sizeof(symboln), "%sFogCoorddv", symbol_prefix);
6589         *procp = dlsym(handle, symboln);
6590     }
6591
6592
6593     if(!disp->FogCoorddvEXT) {
6594         void ** procp = (void **) &disp->FogCoorddvEXT;
6595         snprintf(symboln, sizeof(symboln), "%sFogCoorddvEXT", symbol_prefix);
6596         *procp = dlsym(handle, symboln);
6597     }
6598
6599
6600     if(!disp->FogCoordfEXT) {
6601         void ** procp = (void **) &disp->FogCoordfEXT;
6602         snprintf(symboln, sizeof(symboln), "%sFogCoordf", symbol_prefix);
6603         *procp = dlsym(handle, symboln);
6604     }
6605
6606
6607     if(!disp->FogCoordfEXT) {
6608         void ** procp = (void **) &disp->FogCoordfEXT;
6609         snprintf(symboln, sizeof(symboln), "%sFogCoordfEXT", symbol_prefix);
6610         *procp = dlsym(handle, symboln);
6611     }
6612
6613
6614     if(!disp->FogCoordfvEXT) {
6615         void ** procp = (void **) &disp->FogCoordfvEXT;
6616         snprintf(symboln, sizeof(symboln), "%sFogCoordfv", symbol_prefix);
6617         *procp = dlsym(handle, symboln);
6618     }
6619
6620
6621     if(!disp->FogCoordfvEXT) {
6622         void ** procp = (void **) &disp->FogCoordfvEXT;
6623         snprintf(symboln, sizeof(symboln), "%sFogCoordfvEXT", symbol_prefix);
6624         *procp = dlsym(handle, symboln);
6625     }
6626
6627
6628     if(!disp->PixelTexGenSGIX) {
6629         void ** procp = (void **) &disp->PixelTexGenSGIX;
6630         snprintf(symboln, sizeof(symboln), "%sPixelTexGenSGIX", symbol_prefix);
6631         *procp = dlsym(handle, symboln);
6632     }
6633
6634
6635     if(!disp->BlendFuncSeparateEXT) {
6636         void ** procp = (void **) &disp->BlendFuncSeparateEXT;
6637         snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparate", symbol_prefix);
6638         *procp = dlsym(handle, symboln);
6639     }
6640
6641
6642     if(!disp->BlendFuncSeparateEXT) {
6643         void ** procp = (void **) &disp->BlendFuncSeparateEXT;
6644         snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateEXT", symbol_prefix);
6645         *procp = dlsym(handle, symboln);
6646     }
6647
6648
6649     if(!disp->BlendFuncSeparateEXT) {
6650         void ** procp = (void **) &disp->BlendFuncSeparateEXT;
6651         snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateINGR", symbol_prefix);
6652         *procp = dlsym(handle, symboln);
6653     }
6654
6655
6656     if(!disp->FlushVertexArrayRangeNV) {
6657         void ** procp = (void **) &disp->FlushVertexArrayRangeNV;
6658         snprintf(symboln, sizeof(symboln), "%sFlushVertexArrayRangeNV", symbol_prefix);
6659         *procp = dlsym(handle, symboln);
6660     }
6661
6662
6663     if(!disp->VertexArrayRangeNV) {
6664         void ** procp = (void **) &disp->VertexArrayRangeNV;
6665         snprintf(symboln, sizeof(symboln), "%sVertexArrayRangeNV", symbol_prefix);
6666         *procp = dlsym(handle, symboln);
6667     }
6668
6669
6670     if(!disp->CombinerInputNV) {
6671         void ** procp = (void **) &disp->CombinerInputNV;
6672         snprintf(symboln, sizeof(symboln), "%sCombinerInputNV", symbol_prefix);
6673         *procp = dlsym(handle, symboln);
6674     }
6675
6676
6677     if(!disp->CombinerOutputNV) {
6678         void ** procp = (void **) &disp->CombinerOutputNV;
6679         snprintf(symboln, sizeof(symboln), "%sCombinerOutputNV", symbol_prefix);
6680         *procp = dlsym(handle, symboln);
6681     }
6682
6683
6684     if(!disp->CombinerParameterfNV) {
6685         void ** procp = (void **) &disp->CombinerParameterfNV;
6686         snprintf(symboln, sizeof(symboln), "%sCombinerParameterfNV", symbol_prefix);
6687         *procp = dlsym(handle, symboln);
6688     }
6689
6690
6691     if(!disp->CombinerParameterfvNV) {
6692         void ** procp = (void **) &disp->CombinerParameterfvNV;
6693         snprintf(symboln, sizeof(symboln), "%sCombinerParameterfvNV", symbol_prefix);
6694         *procp = dlsym(handle, symboln);
6695     }
6696
6697
6698     if(!disp->CombinerParameteriNV) {
6699         void ** procp = (void **) &disp->CombinerParameteriNV;
6700         snprintf(symboln, sizeof(symboln), "%sCombinerParameteriNV", symbol_prefix);
6701         *procp = dlsym(handle, symboln);
6702     }
6703
6704
6705     if(!disp->CombinerParameterivNV) {
6706         void ** procp = (void **) &disp->CombinerParameterivNV;
6707         snprintf(symboln, sizeof(symboln), "%sCombinerParameterivNV", symbol_prefix);
6708         *procp = dlsym(handle, symboln);
6709     }
6710
6711
6712     if(!disp->FinalCombinerInputNV) {
6713         void ** procp = (void **) &disp->FinalCombinerInputNV;
6714         snprintf(symboln, sizeof(symboln), "%sFinalCombinerInputNV", symbol_prefix);
6715         *procp = dlsym(handle, symboln);
6716     }
6717
6718
6719     if(!disp->GetCombinerInputParameterfvNV) {
6720         void ** procp = (void **) &disp->GetCombinerInputParameterfvNV;
6721         snprintf(symboln, sizeof(symboln), "%sGetCombinerInputParameterfvNV", symbol_prefix);
6722         *procp = dlsym(handle, symboln);
6723     }
6724
6725
6726     if(!disp->GetCombinerInputParameterivNV) {
6727         void ** procp = (void **) &disp->GetCombinerInputParameterivNV;
6728         snprintf(symboln, sizeof(symboln), "%sGetCombinerInputParameterivNV", symbol_prefix);
6729         *procp = dlsym(handle, symboln);
6730     }
6731
6732
6733     if(!disp->GetCombinerOutputParameterfvNV) {
6734         void ** procp = (void **) &disp->GetCombinerOutputParameterfvNV;
6735         snprintf(symboln, sizeof(symboln), "%sGetCombinerOutputParameterfvNV", symbol_prefix);
6736         *procp = dlsym(handle, symboln);
6737     }
6738
6739
6740     if(!disp->GetCombinerOutputParameterivNV) {
6741         void ** procp = (void **) &disp->GetCombinerOutputParameterivNV;
6742         snprintf(symboln, sizeof(symboln), "%sGetCombinerOutputParameterivNV", symbol_prefix);
6743         *procp = dlsym(handle, symboln);
6744     }
6745
6746
6747     if(!disp->GetFinalCombinerInputParameterfvNV) {
6748         void ** procp = (void **) &disp->GetFinalCombinerInputParameterfvNV;
6749         snprintf(symboln, sizeof(symboln), "%sGetFinalCombinerInputParameterfvNV", symbol_prefix);
6750         *procp = dlsym(handle, symboln);
6751     }
6752
6753
6754     if(!disp->GetFinalCombinerInputParameterivNV) {
6755         void ** procp = (void **) &disp->GetFinalCombinerInputParameterivNV;
6756         snprintf(symboln, sizeof(symboln), "%sGetFinalCombinerInputParameterivNV", symbol_prefix);
6757         *procp = dlsym(handle, symboln);
6758     }
6759
6760
6761     if(!disp->ResizeBuffersMESA) {
6762         void ** procp = (void **) &disp->ResizeBuffersMESA;
6763         snprintf(symboln, sizeof(symboln), "%sResizeBuffersMESA", symbol_prefix);
6764         *procp = dlsym(handle, symboln);
6765     }
6766
6767
6768     if(!disp->WindowPos2dMESA) {
6769         void ** procp = (void **) &disp->WindowPos2dMESA;
6770         snprintf(symboln, sizeof(symboln), "%sWindowPos2d", symbol_prefix);
6771         *procp = dlsym(handle, symboln);
6772     }
6773
6774
6775     if(!disp->WindowPos2dMESA) {
6776         void ** procp = (void **) &disp->WindowPos2dMESA;
6777         snprintf(symboln, sizeof(symboln), "%sWindowPos2dARB", symbol_prefix);
6778         *procp = dlsym(handle, symboln);
6779     }
6780
6781
6782     if(!disp->WindowPos2dMESA) {
6783         void ** procp = (void **) &disp->WindowPos2dMESA;
6784         snprintf(symboln, sizeof(symboln), "%sWindowPos2dMESA", symbol_prefix);
6785         *procp = dlsym(handle, symboln);
6786     }
6787
6788
6789     if(!disp->WindowPos2dvMESA) {
6790         void ** procp = (void **) &disp->WindowPos2dvMESA;
6791         snprintf(symboln, sizeof(symboln), "%sWindowPos2dv", symbol_prefix);
6792         *procp = dlsym(handle, symboln);
6793     }
6794
6795
6796     if(!disp->WindowPos2dvMESA) {
6797         void ** procp = (void **) &disp->WindowPos2dvMESA;
6798         snprintf(symboln, sizeof(symboln), "%sWindowPos2dvARB", symbol_prefix);
6799         *procp = dlsym(handle, symboln);
6800     }
6801
6802
6803     if(!disp->WindowPos2dvMESA) {
6804         void ** procp = (void **) &disp->WindowPos2dvMESA;
6805         snprintf(symboln, sizeof(symboln), "%sWindowPos2dvMESA", symbol_prefix);
6806         *procp = dlsym(handle, symboln);
6807     }
6808
6809
6810     if(!disp->WindowPos2fMESA) {
6811         void ** procp = (void **) &disp->WindowPos2fMESA;
6812         snprintf(symboln, sizeof(symboln), "%sWindowPos2f", symbol_prefix);
6813         *procp = dlsym(handle, symboln);
6814     }
6815
6816
6817     if(!disp->WindowPos2fMESA) {
6818         void ** procp = (void **) &disp->WindowPos2fMESA;
6819         snprintf(symboln, sizeof(symboln), "%sWindowPos2fARB", symbol_prefix);
6820         *procp = dlsym(handle, symboln);
6821     }
6822
6823
6824     if(!disp->WindowPos2fMESA) {
6825         void ** procp = (void **) &disp->WindowPos2fMESA;
6826         snprintf(symboln, sizeof(symboln), "%sWindowPos2fMESA", symbol_prefix);
6827         *procp = dlsym(handle, symboln);
6828     }
6829
6830
6831     if(!disp->WindowPos2fvMESA) {
6832         void ** procp = (void **) &disp->WindowPos2fvMESA;
6833         snprintf(symboln, sizeof(symboln), "%sWindowPos2fv", symbol_prefix);
6834         *procp = dlsym(handle, symboln);
6835     }
6836
6837
6838     if(!disp->WindowPos2fvMESA) {
6839         void ** procp = (void **) &disp->WindowPos2fvMESA;
6840         snprintf(symboln, sizeof(symboln), "%sWindowPos2fvARB", symbol_prefix);
6841         *procp = dlsym(handle, symboln);
6842     }
6843
6844
6845     if(!disp->WindowPos2fvMESA) {
6846         void ** procp = (void **) &disp->WindowPos2fvMESA;
6847         snprintf(symboln, sizeof(symboln), "%sWindowPos2fvMESA", symbol_prefix);
6848         *procp = dlsym(handle, symboln);
6849     }
6850
6851
6852     if(!disp->WindowPos2iMESA) {
6853         void ** procp = (void **) &disp->WindowPos2iMESA;
6854         snprintf(symboln, sizeof(symboln), "%sWindowPos2i", symbol_prefix);
6855         *procp = dlsym(handle, symboln);
6856     }
6857
6858
6859     if(!disp->WindowPos2iMESA) {
6860         void ** procp = (void **) &disp->WindowPos2iMESA;
6861         snprintf(symboln, sizeof(symboln), "%sWindowPos2iARB", symbol_prefix);
6862         *procp = dlsym(handle, symboln);
6863     }
6864
6865
6866     if(!disp->WindowPos2iMESA) {
6867         void ** procp = (void **) &disp->WindowPos2iMESA;
6868         snprintf(symboln, sizeof(symboln), "%sWindowPos2iMESA", symbol_prefix);
6869         *procp = dlsym(handle, symboln);
6870     }
6871
6872
6873     if(!disp->WindowPos2ivMESA) {
6874         void ** procp = (void **) &disp->WindowPos2ivMESA;
6875         snprintf(symboln, sizeof(symboln), "%sWindowPos2iv", symbol_prefix);
6876         *procp = dlsym(handle, symboln);
6877     }
6878
6879
6880     if(!disp->WindowPos2ivMESA) {
6881         void ** procp = (void **) &disp->WindowPos2ivMESA;
6882         snprintf(symboln, sizeof(symboln), "%sWindowPos2ivARB", symbol_prefix);
6883         *procp = dlsym(handle, symboln);
6884     }
6885
6886
6887     if(!disp->WindowPos2ivMESA) {
6888         void ** procp = (void **) &disp->WindowPos2ivMESA;
6889         snprintf(symboln, sizeof(symboln), "%sWindowPos2ivMESA", symbol_prefix);
6890         *procp = dlsym(handle, symboln);
6891     }
6892
6893
6894     if(!disp->WindowPos2sMESA) {
6895         void ** procp = (void **) &disp->WindowPos2sMESA;
6896         snprintf(symboln, sizeof(symboln), "%sWindowPos2s", symbol_prefix);
6897         *procp = dlsym(handle, symboln);
6898     }
6899
6900
6901     if(!disp->WindowPos2sMESA) {
6902         void ** procp = (void **) &disp->WindowPos2sMESA;
6903         snprintf(symboln, sizeof(symboln), "%sWindowPos2sARB", symbol_prefix);
6904         *procp = dlsym(handle, symboln);
6905     }
6906
6907
6908     if(!disp->WindowPos2sMESA) {
6909         void ** procp = (void **) &disp->WindowPos2sMESA;
6910         snprintf(symboln, sizeof(symboln), "%sWindowPos2sMESA", symbol_prefix);
6911         *procp = dlsym(handle, symboln);
6912     }
6913
6914
6915     if(!disp->WindowPos2svMESA) {
6916         void ** procp = (void **) &disp->WindowPos2svMESA;
6917         snprintf(symboln, sizeof(symboln), "%sWindowPos2sv", symbol_prefix);
6918         *procp = dlsym(handle, symboln);
6919     }
6920
6921
6922     if(!disp->WindowPos2svMESA) {
6923         void ** procp = (void **) &disp->WindowPos2svMESA;
6924         snprintf(symboln, sizeof(symboln), "%sWindowPos2svARB", symbol_prefix);
6925         *procp = dlsym(handle, symboln);
6926     }
6927
6928
6929     if(!disp->WindowPos2svMESA) {
6930         void ** procp = (void **) &disp->WindowPos2svMESA;
6931         snprintf(symboln, sizeof(symboln), "%sWindowPos2svMESA", symbol_prefix);
6932         *procp = dlsym(handle, symboln);
6933     }
6934
6935
6936     if(!disp->WindowPos3dMESA) {
6937         void ** procp = (void **) &disp->WindowPos3dMESA;
6938         snprintf(symboln, sizeof(symboln), "%sWindowPos3d", symbol_prefix);
6939         *procp = dlsym(handle, symboln);
6940     }
6941
6942
6943     if(!disp->WindowPos3dMESA) {
6944         void ** procp = (void **) &disp->WindowPos3dMESA;
6945         snprintf(symboln, sizeof(symboln), "%sWindowPos3dARB", symbol_prefix);
6946         *procp = dlsym(handle, symboln);
6947     }
6948
6949
6950     if(!disp->WindowPos3dMESA) {
6951         void ** procp = (void **) &disp->WindowPos3dMESA;
6952         snprintf(symboln, sizeof(symboln), "%sWindowPos3dMESA", symbol_prefix);
6953         *procp = dlsym(handle, symboln);
6954     }
6955
6956
6957     if(!disp->WindowPos3dvMESA) {
6958         void ** procp = (void **) &disp->WindowPos3dvMESA;
6959         snprintf(symboln, sizeof(symboln), "%sWindowPos3dv", symbol_prefix);
6960         *procp = dlsym(handle, symboln);
6961     }
6962
6963
6964     if(!disp->WindowPos3dvMESA) {
6965         void ** procp = (void **) &disp->WindowPos3dvMESA;
6966         snprintf(symboln, sizeof(symboln), "%sWindowPos3dvARB", symbol_prefix);
6967         *procp = dlsym(handle, symboln);
6968     }
6969
6970
6971     if(!disp->WindowPos3dvMESA) {
6972         void ** procp = (void **) &disp->WindowPos3dvMESA;
6973         snprintf(symboln, sizeof(symboln), "%sWindowPos3dvMESA", symbol_prefix);
6974         *procp = dlsym(handle, symboln);
6975     }
6976
6977
6978     if(!disp->WindowPos3fMESA) {
6979         void ** procp = (void **) &disp->WindowPos3fMESA;
6980         snprintf(symboln, sizeof(symboln), "%sWindowPos3f", symbol_prefix);
6981         *procp = dlsym(handle, symboln);
6982     }
6983
6984
6985     if(!disp->WindowPos3fMESA) {
6986         void ** procp = (void **) &disp->WindowPos3fMESA;
6987         snprintf(symboln, sizeof(symboln), "%sWindowPos3fARB", symbol_prefix);
6988         *procp = dlsym(handle, symboln);
6989     }
6990
6991
6992     if(!disp->WindowPos3fMESA) {
6993         void ** procp = (void **) &disp->WindowPos3fMESA;
6994         snprintf(symboln, sizeof(symboln), "%sWindowPos3fMESA", symbol_prefix);
6995         *procp = dlsym(handle, symboln);
6996     }
6997
6998
6999     if(!disp->WindowPos3fvMESA) {
7000         void ** procp = (void **) &disp->WindowPos3fvMESA;
7001         snprintf(symboln, sizeof(symboln), "%sWindowPos3fv", symbol_prefix);
7002         *procp = dlsym(handle, symboln);
7003     }
7004
7005
7006     if(!disp->WindowPos3fvMESA) {
7007         void ** procp = (void **) &disp->WindowPos3fvMESA;
7008         snprintf(symboln, sizeof(symboln), "%sWindowPos3fvARB", symbol_prefix);
7009         *procp = dlsym(handle, symboln);
7010     }
7011
7012
7013     if(!disp->WindowPos3fvMESA) {
7014         void ** procp = (void **) &disp->WindowPos3fvMESA;
7015         snprintf(symboln, sizeof(symboln), "%sWindowPos3fvMESA", symbol_prefix);
7016         *procp = dlsym(handle, symboln);
7017     }
7018
7019
7020     if(!disp->WindowPos3iMESA) {
7021         void ** procp = (void **) &disp->WindowPos3iMESA;
7022         snprintf(symboln, sizeof(symboln), "%sWindowPos3i", symbol_prefix);
7023         *procp = dlsym(handle, symboln);
7024     }
7025
7026
7027     if(!disp->WindowPos3iMESA) {
7028         void ** procp = (void **) &disp->WindowPos3iMESA;
7029         snprintf(symboln, sizeof(symboln), "%sWindowPos3iARB", symbol_prefix);
7030         *procp = dlsym(handle, symboln);
7031     }
7032
7033
7034     if(!disp->WindowPos3iMESA) {
7035         void ** procp = (void **) &disp->WindowPos3iMESA;
7036         snprintf(symboln, sizeof(symboln), "%sWindowPos3iMESA", symbol_prefix);
7037         *procp = dlsym(handle, symboln);
7038     }
7039
7040
7041     if(!disp->WindowPos3ivMESA) {
7042         void ** procp = (void **) &disp->WindowPos3ivMESA;
7043         snprintf(symboln, sizeof(symboln), "%sWindowPos3iv", symbol_prefix);
7044         *procp = dlsym(handle, symboln);
7045     }
7046
7047
7048     if(!disp->WindowPos3ivMESA) {
7049         void ** procp = (void **) &disp->WindowPos3ivMESA;
7050         snprintf(symboln, sizeof(symboln), "%sWindowPos3ivARB", symbol_prefix);
7051         *procp = dlsym(handle, symboln);
7052     }
7053
7054
7055     if(!disp->WindowPos3ivMESA) {
7056         void ** procp = (void **) &disp->WindowPos3ivMESA;
7057         snprintf(symboln, sizeof(symboln), "%sWindowPos3ivMESA", symbol_prefix);
7058         *procp = dlsym(handle, symboln);
7059     }
7060
7061
7062     if(!disp->WindowPos3sMESA) {
7063         void ** procp = (void **) &disp->WindowPos3sMESA;
7064         snprintf(symboln, sizeof(symboln), "%sWindowPos3s", symbol_prefix);
7065         *procp = dlsym(handle, symboln);
7066     }
7067
7068
7069     if(!disp->WindowPos3sMESA) {
7070         void ** procp = (void **) &disp->WindowPos3sMESA;
7071         snprintf(symboln, sizeof(symboln), "%sWindowPos3sARB", symbol_prefix);
7072         *procp = dlsym(handle, symboln);
7073     }
7074
7075
7076     if(!disp->WindowPos3sMESA) {
7077         void ** procp = (void **) &disp->WindowPos3sMESA;
7078         snprintf(symboln, sizeof(symboln), "%sWindowPos3sMESA", symbol_prefix);
7079         *procp = dlsym(handle, symboln);
7080     }
7081
7082
7083     if(!disp->WindowPos3svMESA) {
7084         void ** procp = (void **) &disp->WindowPos3svMESA;
7085         snprintf(symboln, sizeof(symboln), "%sWindowPos3sv", symbol_prefix);
7086         *procp = dlsym(handle, symboln);
7087     }
7088
7089
7090     if(!disp->WindowPos3svMESA) {
7091         void ** procp = (void **) &disp->WindowPos3svMESA;
7092         snprintf(symboln, sizeof(symboln), "%sWindowPos3svARB", symbol_prefix);
7093         *procp = dlsym(handle, symboln);
7094     }
7095
7096
7097     if(!disp->WindowPos3svMESA) {
7098         void ** procp = (void **) &disp->WindowPos3svMESA;
7099         snprintf(symboln, sizeof(symboln), "%sWindowPos3svMESA", symbol_prefix);
7100         *procp = dlsym(handle, symboln);
7101     }
7102
7103
7104     if(!disp->WindowPos4dMESA) {
7105         void ** procp = (void **) &disp->WindowPos4dMESA;
7106         snprintf(symboln, sizeof(symboln), "%sWindowPos4dMESA", symbol_prefix);
7107         *procp = dlsym(handle, symboln);
7108     }
7109
7110
7111     if(!disp->WindowPos4dvMESA) {
7112         void ** procp = (void **) &disp->WindowPos4dvMESA;
7113         snprintf(symboln, sizeof(symboln), "%sWindowPos4dvMESA", symbol_prefix);
7114         *procp = dlsym(handle, symboln);
7115     }
7116
7117
7118     if(!disp->WindowPos4fMESA) {
7119         void ** procp = (void **) &disp->WindowPos4fMESA;
7120         snprintf(symboln, sizeof(symboln), "%sWindowPos4fMESA", symbol_prefix);
7121         *procp = dlsym(handle, symboln);
7122     }
7123
7124
7125     if(!disp->WindowPos4fvMESA) {
7126         void ** procp = (void **) &disp->WindowPos4fvMESA;
7127         snprintf(symboln, sizeof(symboln), "%sWindowPos4fvMESA", symbol_prefix);
7128         *procp = dlsym(handle, symboln);
7129     }
7130
7131
7132     if(!disp->WindowPos4iMESA) {
7133         void ** procp = (void **) &disp->WindowPos4iMESA;
7134         snprintf(symboln, sizeof(symboln), "%sWindowPos4iMESA", symbol_prefix);
7135         *procp = dlsym(handle, symboln);
7136     }
7137
7138
7139     if(!disp->WindowPos4ivMESA) {
7140         void ** procp = (void **) &disp->WindowPos4ivMESA;
7141         snprintf(symboln, sizeof(symboln), "%sWindowPos4ivMESA", symbol_prefix);
7142         *procp = dlsym(handle, symboln);
7143     }
7144
7145
7146     if(!disp->WindowPos4sMESA) {
7147         void ** procp = (void **) &disp->WindowPos4sMESA;
7148         snprintf(symboln, sizeof(symboln), "%sWindowPos4sMESA", symbol_prefix);
7149         *procp = dlsym(handle, symboln);
7150     }
7151
7152
7153     if(!disp->WindowPos4svMESA) {
7154         void ** procp = (void **) &disp->WindowPos4svMESA;
7155         snprintf(symboln, sizeof(symboln), "%sWindowPos4svMESA", symbol_prefix);
7156         *procp = dlsym(handle, symboln);
7157     }
7158
7159
7160     if(!disp->MultiModeDrawArraysIBM) {
7161         void ** procp = (void **) &disp->MultiModeDrawArraysIBM;
7162         snprintf(symboln, sizeof(symboln), "%sMultiModeDrawArraysIBM", symbol_prefix);
7163         *procp = dlsym(handle, symboln);
7164     }
7165
7166
7167     if(!disp->MultiModeDrawElementsIBM) {
7168         void ** procp = (void **) &disp->MultiModeDrawElementsIBM;
7169         snprintf(symboln, sizeof(symboln), "%sMultiModeDrawElementsIBM", symbol_prefix);
7170         *procp = dlsym(handle, symboln);
7171     }
7172
7173
7174     if(!disp->DeleteFencesNV) {
7175         void ** procp = (void **) &disp->DeleteFencesNV;
7176         snprintf(symboln, sizeof(symboln), "%sDeleteFencesNV", symbol_prefix);
7177         *procp = dlsym(handle, symboln);
7178     }
7179
7180
7181     if(!disp->FinishFenceNV) {
7182         void ** procp = (void **) &disp->FinishFenceNV;
7183         snprintf(symboln, sizeof(symboln), "%sFinishFenceNV", symbol_prefix);
7184         *procp = dlsym(handle, symboln);
7185     }
7186
7187
7188     if(!disp->GenFencesNV) {
7189         void ** procp = (void **) &disp->GenFencesNV;
7190         snprintf(symboln, sizeof(symboln), "%sGenFencesNV", symbol_prefix);
7191         *procp = dlsym(handle, symboln);
7192     }
7193
7194
7195     if(!disp->GetFenceivNV) {
7196         void ** procp = (void **) &disp->GetFenceivNV;
7197         snprintf(symboln, sizeof(symboln), "%sGetFenceivNV", symbol_prefix);
7198         *procp = dlsym(handle, symboln);
7199     }
7200
7201
7202     if(!disp->IsFenceNV) {
7203         void ** procp = (void **) &disp->IsFenceNV;
7204         snprintf(symboln, sizeof(symboln), "%sIsFenceNV", symbol_prefix);
7205         *procp = dlsym(handle, symboln);
7206     }
7207
7208
7209     if(!disp->SetFenceNV) {
7210         void ** procp = (void **) &disp->SetFenceNV;
7211         snprintf(symboln, sizeof(symboln), "%sSetFenceNV", symbol_prefix);
7212         *procp = dlsym(handle, symboln);
7213     }
7214
7215
7216     if(!disp->TestFenceNV) {
7217         void ** procp = (void **) &disp->TestFenceNV;
7218         snprintf(symboln, sizeof(symboln), "%sTestFenceNV", symbol_prefix);
7219         *procp = dlsym(handle, symboln);
7220     }
7221
7222
7223     if(!disp->AreProgramsResidentNV) {
7224         void ** procp = (void **) &disp->AreProgramsResidentNV;
7225         snprintf(symboln, sizeof(symboln), "%sAreProgramsResidentNV", symbol_prefix);
7226         *procp = dlsym(handle, symboln);
7227     }
7228
7229
7230     if(!disp->BindProgramNV) {
7231         void ** procp = (void **) &disp->BindProgramNV;
7232         snprintf(symboln, sizeof(symboln), "%sBindProgramARB", symbol_prefix);
7233         *procp = dlsym(handle, symboln);
7234     }
7235
7236
7237     if(!disp->BindProgramNV) {
7238         void ** procp = (void **) &disp->BindProgramNV;
7239         snprintf(symboln, sizeof(symboln), "%sBindProgramNV", symbol_prefix);
7240         *procp = dlsym(handle, symboln);
7241     }
7242
7243
7244     if(!disp->DeleteProgramsNV) {
7245         void ** procp = (void **) &disp->DeleteProgramsNV;
7246         snprintf(symboln, sizeof(symboln), "%sDeleteProgramsARB", symbol_prefix);
7247         *procp = dlsym(handle, symboln);
7248     }
7249
7250
7251     if(!disp->DeleteProgramsNV) {
7252         void ** procp = (void **) &disp->DeleteProgramsNV;
7253         snprintf(symboln, sizeof(symboln), "%sDeleteProgramsNV", symbol_prefix);
7254         *procp = dlsym(handle, symboln);
7255     }
7256
7257
7258     if(!disp->ExecuteProgramNV) {
7259         void ** procp = (void **) &disp->ExecuteProgramNV;
7260         snprintf(symboln, sizeof(symboln), "%sExecuteProgramNV", symbol_prefix);
7261         *procp = dlsym(handle, symboln);
7262     }
7263
7264
7265     if(!disp->GenProgramsNV) {
7266         void ** procp = (void **) &disp->GenProgramsNV;
7267         snprintf(symboln, sizeof(symboln), "%sGenProgramsARB", symbol_prefix);
7268         *procp = dlsym(handle, symboln);
7269     }
7270
7271
7272     if(!disp->GenProgramsNV) {
7273         void ** procp = (void **) &disp->GenProgramsNV;
7274         snprintf(symboln, sizeof(symboln), "%sGenProgramsNV", symbol_prefix);
7275         *procp = dlsym(handle, symboln);
7276     }
7277
7278
7279     if(!disp->GetProgramParameterdvNV) {
7280         void ** procp = (void **) &disp->GetProgramParameterdvNV;
7281         snprintf(symboln, sizeof(symboln), "%sGetProgramParameterdvNV", symbol_prefix);
7282         *procp = dlsym(handle, symboln);
7283     }
7284
7285
7286     if(!disp->GetProgramParameterfvNV) {
7287         void ** procp = (void **) &disp->GetProgramParameterfvNV;
7288         snprintf(symboln, sizeof(symboln), "%sGetProgramParameterfvNV", symbol_prefix);
7289         *procp = dlsym(handle, symboln);
7290     }
7291
7292
7293     if(!disp->GetProgramStringNV) {
7294         void ** procp = (void **) &disp->GetProgramStringNV;
7295         snprintf(symboln, sizeof(symboln), "%sGetProgramStringNV", symbol_prefix);
7296         *procp = dlsym(handle, symboln);
7297     }
7298
7299
7300     if(!disp->GetProgramivNV) {
7301         void ** procp = (void **) &disp->GetProgramivNV;
7302         snprintf(symboln, sizeof(symboln), "%sGetProgramivNV", symbol_prefix);
7303         *procp = dlsym(handle, symboln);
7304     }
7305
7306
7307     if(!disp->GetTrackMatrixivNV) {
7308         void ** procp = (void **) &disp->GetTrackMatrixivNV;
7309         snprintf(symboln, sizeof(symboln), "%sGetTrackMatrixivNV", symbol_prefix);
7310         *procp = dlsym(handle, symboln);
7311     }
7312
7313
7314     if(!disp->GetVertexAttribPointervNV) {
7315         void ** procp = (void **) &disp->GetVertexAttribPointervNV;
7316         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribPointerv", symbol_prefix);
7317         *procp = dlsym(handle, symboln);
7318     }
7319
7320
7321     if(!disp->GetVertexAttribPointervNV) {
7322         void ** procp = (void **) &disp->GetVertexAttribPointervNV;
7323         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribPointervARB", symbol_prefix);
7324         *procp = dlsym(handle, symboln);
7325     }
7326
7327
7328     if(!disp->GetVertexAttribPointervNV) {
7329         void ** procp = (void **) &disp->GetVertexAttribPointervNV;
7330         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribPointervNV", symbol_prefix);
7331         *procp = dlsym(handle, symboln);
7332     }
7333
7334
7335     if(!disp->GetVertexAttribdvNV) {
7336         void ** procp = (void **) &disp->GetVertexAttribdvNV;
7337         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribdvNV", symbol_prefix);
7338         *procp = dlsym(handle, symboln);
7339     }
7340
7341
7342     if(!disp->GetVertexAttribfvNV) {
7343         void ** procp = (void **) &disp->GetVertexAttribfvNV;
7344         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribfvNV", symbol_prefix);
7345         *procp = dlsym(handle, symboln);
7346     }
7347
7348
7349     if(!disp->GetVertexAttribivNV) {
7350         void ** procp = (void **) &disp->GetVertexAttribivNV;
7351         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribivNV", symbol_prefix);
7352         *procp = dlsym(handle, symboln);
7353     }
7354
7355
7356     if(!disp->IsProgramNV) {
7357         void ** procp = (void **) &disp->IsProgramNV;
7358         snprintf(symboln, sizeof(symboln), "%sIsProgramARB", symbol_prefix);
7359         *procp = dlsym(handle, symboln);
7360     }
7361
7362
7363     if(!disp->IsProgramNV) {
7364         void ** procp = (void **) &disp->IsProgramNV;
7365         snprintf(symboln, sizeof(symboln), "%sIsProgramNV", symbol_prefix);
7366         *procp = dlsym(handle, symboln);
7367     }
7368
7369
7370     if(!disp->LoadProgramNV) {
7371         void ** procp = (void **) &disp->LoadProgramNV;
7372         snprintf(symboln, sizeof(symboln), "%sLoadProgramNV", symbol_prefix);
7373         *procp = dlsym(handle, symboln);
7374     }
7375
7376
7377     if(!disp->ProgramParameters4dvNV) {
7378         void ** procp = (void **) &disp->ProgramParameters4dvNV;
7379         snprintf(symboln, sizeof(symboln), "%sProgramParameters4dvNV", symbol_prefix);
7380         *procp = dlsym(handle, symboln);
7381     }
7382
7383
7384     if(!disp->ProgramParameters4fvNV) {
7385         void ** procp = (void **) &disp->ProgramParameters4fvNV;
7386         snprintf(symboln, sizeof(symboln), "%sProgramParameters4fvNV", symbol_prefix);
7387         *procp = dlsym(handle, symboln);
7388     }
7389
7390
7391     if(!disp->RequestResidentProgramsNV) {
7392         void ** procp = (void **) &disp->RequestResidentProgramsNV;
7393         snprintf(symboln, sizeof(symboln), "%sRequestResidentProgramsNV", symbol_prefix);
7394         *procp = dlsym(handle, symboln);
7395     }
7396
7397
7398     if(!disp->TrackMatrixNV) {
7399         void ** procp = (void **) &disp->TrackMatrixNV;
7400         snprintf(symboln, sizeof(symboln), "%sTrackMatrixNV", symbol_prefix);
7401         *procp = dlsym(handle, symboln);
7402     }
7403
7404
7405     if(!disp->VertexAttrib1dNV) {
7406         void ** procp = (void **) &disp->VertexAttrib1dNV;
7407         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dNV", symbol_prefix);
7408         *procp = dlsym(handle, symboln);
7409     }
7410
7411
7412     if(!disp->VertexAttrib1dvNV) {
7413         void ** procp = (void **) &disp->VertexAttrib1dvNV;
7414         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dvNV", symbol_prefix);
7415         *procp = dlsym(handle, symboln);
7416     }
7417
7418
7419     if(!disp->VertexAttrib1fNV) {
7420         void ** procp = (void **) &disp->VertexAttrib1fNV;
7421         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fNV", symbol_prefix);
7422         *procp = dlsym(handle, symboln);
7423     }
7424
7425
7426     if(!disp->VertexAttrib1fvNV) {
7427         void ** procp = (void **) &disp->VertexAttrib1fvNV;
7428         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fvNV", symbol_prefix);
7429         *procp = dlsym(handle, symboln);
7430     }
7431
7432
7433     if(!disp->VertexAttrib1sNV) {
7434         void ** procp = (void **) &disp->VertexAttrib1sNV;
7435         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1sNV", symbol_prefix);
7436         *procp = dlsym(handle, symboln);
7437     }
7438
7439
7440     if(!disp->VertexAttrib1svNV) {
7441         void ** procp = (void **) &disp->VertexAttrib1svNV;
7442         snprintf(symboln, sizeof(symboln), "%sVertexAttrib1svNV", symbol_prefix);
7443         *procp = dlsym(handle, symboln);
7444     }
7445
7446
7447     if(!disp->VertexAttrib2dNV) {
7448         void ** procp = (void **) &disp->VertexAttrib2dNV;
7449         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dNV", symbol_prefix);
7450         *procp = dlsym(handle, symboln);
7451     }
7452
7453
7454     if(!disp->VertexAttrib2dvNV) {
7455         void ** procp = (void **) &disp->VertexAttrib2dvNV;
7456         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dvNV", symbol_prefix);
7457         *procp = dlsym(handle, symboln);
7458     }
7459
7460
7461     if(!disp->VertexAttrib2fNV) {
7462         void ** procp = (void **) &disp->VertexAttrib2fNV;
7463         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fNV", symbol_prefix);
7464         *procp = dlsym(handle, symboln);
7465     }
7466
7467
7468     if(!disp->VertexAttrib2fvNV) {
7469         void ** procp = (void **) &disp->VertexAttrib2fvNV;
7470         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fvNV", symbol_prefix);
7471         *procp = dlsym(handle, symboln);
7472     }
7473
7474
7475     if(!disp->VertexAttrib2sNV) {
7476         void ** procp = (void **) &disp->VertexAttrib2sNV;
7477         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2sNV", symbol_prefix);
7478         *procp = dlsym(handle, symboln);
7479     }
7480
7481
7482     if(!disp->VertexAttrib2svNV) {
7483         void ** procp = (void **) &disp->VertexAttrib2svNV;
7484         snprintf(symboln, sizeof(symboln), "%sVertexAttrib2svNV", symbol_prefix);
7485         *procp = dlsym(handle, symboln);
7486     }
7487
7488
7489     if(!disp->VertexAttrib3dNV) {
7490         void ** procp = (void **) &disp->VertexAttrib3dNV;
7491         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dNV", symbol_prefix);
7492         *procp = dlsym(handle, symboln);
7493     }
7494
7495
7496     if(!disp->VertexAttrib3dvNV) {
7497         void ** procp = (void **) &disp->VertexAttrib3dvNV;
7498         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dvNV", symbol_prefix);
7499         *procp = dlsym(handle, symboln);
7500     }
7501
7502
7503     if(!disp->VertexAttrib3fNV) {
7504         void ** procp = (void **) &disp->VertexAttrib3fNV;
7505         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fNV", symbol_prefix);
7506         *procp = dlsym(handle, symboln);
7507     }
7508
7509
7510     if(!disp->VertexAttrib3fvNV) {
7511         void ** procp = (void **) &disp->VertexAttrib3fvNV;
7512         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fvNV", symbol_prefix);
7513         *procp = dlsym(handle, symboln);
7514     }
7515
7516
7517     if(!disp->VertexAttrib3sNV) {
7518         void ** procp = (void **) &disp->VertexAttrib3sNV;
7519         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3sNV", symbol_prefix);
7520         *procp = dlsym(handle, symboln);
7521     }
7522
7523
7524     if(!disp->VertexAttrib3svNV) {
7525         void ** procp = (void **) &disp->VertexAttrib3svNV;
7526         snprintf(symboln, sizeof(symboln), "%sVertexAttrib3svNV", symbol_prefix);
7527         *procp = dlsym(handle, symboln);
7528     }
7529
7530
7531     if(!disp->VertexAttrib4dNV) {
7532         void ** procp = (void **) &disp->VertexAttrib4dNV;
7533         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dNV", symbol_prefix);
7534         *procp = dlsym(handle, symboln);
7535     }
7536
7537
7538     if(!disp->VertexAttrib4dvNV) {
7539         void ** procp = (void **) &disp->VertexAttrib4dvNV;
7540         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dvNV", symbol_prefix);
7541         *procp = dlsym(handle, symboln);
7542     }
7543
7544
7545     if(!disp->VertexAttrib4fNV) {
7546         void ** procp = (void **) &disp->VertexAttrib4fNV;
7547         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fNV", symbol_prefix);
7548         *procp = dlsym(handle, symboln);
7549     }
7550
7551
7552     if(!disp->VertexAttrib4fvNV) {
7553         void ** procp = (void **) &disp->VertexAttrib4fvNV;
7554         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fvNV", symbol_prefix);
7555         *procp = dlsym(handle, symboln);
7556     }
7557
7558
7559     if(!disp->VertexAttrib4sNV) {
7560         void ** procp = (void **) &disp->VertexAttrib4sNV;
7561         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4sNV", symbol_prefix);
7562         *procp = dlsym(handle, symboln);
7563     }
7564
7565
7566     if(!disp->VertexAttrib4svNV) {
7567         void ** procp = (void **) &disp->VertexAttrib4svNV;
7568         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4svNV", symbol_prefix);
7569         *procp = dlsym(handle, symboln);
7570     }
7571
7572
7573     if(!disp->VertexAttrib4ubNV) {
7574         void ** procp = (void **) &disp->VertexAttrib4ubNV;
7575         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubNV", symbol_prefix);
7576         *procp = dlsym(handle, symboln);
7577     }
7578
7579
7580     if(!disp->VertexAttrib4ubvNV) {
7581         void ** procp = (void **) &disp->VertexAttrib4ubvNV;
7582         snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubvNV", symbol_prefix);
7583         *procp = dlsym(handle, symboln);
7584     }
7585
7586
7587     if(!disp->VertexAttribPointerNV) {
7588         void ** procp = (void **) &disp->VertexAttribPointerNV;
7589         snprintf(symboln, sizeof(symboln), "%sVertexAttribPointerNV", symbol_prefix);
7590         *procp = dlsym(handle, symboln);
7591     }
7592
7593
7594     if(!disp->VertexAttribs1dvNV) {
7595         void ** procp = (void **) &disp->VertexAttribs1dvNV;
7596         snprintf(symboln, sizeof(symboln), "%sVertexAttribs1dvNV", symbol_prefix);
7597         *procp = dlsym(handle, symboln);
7598     }
7599
7600
7601     if(!disp->VertexAttribs1fvNV) {
7602         void ** procp = (void **) &disp->VertexAttribs1fvNV;
7603         snprintf(symboln, sizeof(symboln), "%sVertexAttribs1fvNV", symbol_prefix);
7604         *procp = dlsym(handle, symboln);
7605     }
7606
7607
7608     if(!disp->VertexAttribs1svNV) {
7609         void ** procp = (void **) &disp->VertexAttribs1svNV;
7610         snprintf(symboln, sizeof(symboln), "%sVertexAttribs1svNV", symbol_prefix);
7611         *procp = dlsym(handle, symboln);
7612     }
7613
7614
7615     if(!disp->VertexAttribs2dvNV) {
7616         void ** procp = (void **) &disp->VertexAttribs2dvNV;
7617         snprintf(symboln, sizeof(symboln), "%sVertexAttribs2dvNV", symbol_prefix);
7618         *procp = dlsym(handle, symboln);
7619     }
7620
7621
7622     if(!disp->VertexAttribs2fvNV) {
7623         void ** procp = (void **) &disp->VertexAttribs2fvNV;
7624         snprintf(symboln, sizeof(symboln), "%sVertexAttribs2fvNV", symbol_prefix);
7625         *procp = dlsym(handle, symboln);
7626     }
7627
7628
7629     if(!disp->VertexAttribs2svNV) {
7630         void ** procp = (void **) &disp->VertexAttribs2svNV;
7631         snprintf(symboln, sizeof(symboln), "%sVertexAttribs2svNV", symbol_prefix);
7632         *procp = dlsym(handle, symboln);
7633     }
7634
7635
7636     if(!disp->VertexAttribs3dvNV) {
7637         void ** procp = (void **) &disp->VertexAttribs3dvNV;
7638         snprintf(symboln, sizeof(symboln), "%sVertexAttribs3dvNV", symbol_prefix);
7639         *procp = dlsym(handle, symboln);
7640     }
7641
7642
7643     if(!disp->VertexAttribs3fvNV) {
7644         void ** procp = (void **) &disp->VertexAttribs3fvNV;
7645         snprintf(symboln, sizeof(symboln), "%sVertexAttribs3fvNV", symbol_prefix);
7646         *procp = dlsym(handle, symboln);
7647     }
7648
7649
7650     if(!disp->VertexAttribs3svNV) {
7651         void ** procp = (void **) &disp->VertexAttribs3svNV;
7652         snprintf(symboln, sizeof(symboln), "%sVertexAttribs3svNV", symbol_prefix);
7653         *procp = dlsym(handle, symboln);
7654     }
7655
7656
7657     if(!disp->VertexAttribs4dvNV) {
7658         void ** procp = (void **) &disp->VertexAttribs4dvNV;
7659         snprintf(symboln, sizeof(symboln), "%sVertexAttribs4dvNV", symbol_prefix);
7660         *procp = dlsym(handle, symboln);
7661     }
7662
7663
7664     if(!disp->VertexAttribs4fvNV) {
7665         void ** procp = (void **) &disp->VertexAttribs4fvNV;
7666         snprintf(symboln, sizeof(symboln), "%sVertexAttribs4fvNV", symbol_prefix);
7667         *procp = dlsym(handle, symboln);
7668     }
7669
7670
7671     if(!disp->VertexAttribs4svNV) {
7672         void ** procp = (void **) &disp->VertexAttribs4svNV;
7673         snprintf(symboln, sizeof(symboln), "%sVertexAttribs4svNV", symbol_prefix);
7674         *procp = dlsym(handle, symboln);
7675     }
7676
7677
7678     if(!disp->VertexAttribs4ubvNV) {
7679         void ** procp = (void **) &disp->VertexAttribs4ubvNV;
7680         snprintf(symboln, sizeof(symboln), "%sVertexAttribs4ubvNV", symbol_prefix);
7681         *procp = dlsym(handle, symboln);
7682     }
7683
7684
7685     if(!disp->GetTexBumpParameterfvATI) {
7686         void ** procp = (void **) &disp->GetTexBumpParameterfvATI;
7687         snprintf(symboln, sizeof(symboln), "%sGetTexBumpParameterfvATI", symbol_prefix);
7688         *procp = dlsym(handle, symboln);
7689     }
7690
7691
7692     if(!disp->GetTexBumpParameterivATI) {
7693         void ** procp = (void **) &disp->GetTexBumpParameterivATI;
7694         snprintf(symboln, sizeof(symboln), "%sGetTexBumpParameterivATI", symbol_prefix);
7695         *procp = dlsym(handle, symboln);
7696     }
7697
7698
7699     if(!disp->TexBumpParameterfvATI) {
7700         void ** procp = (void **) &disp->TexBumpParameterfvATI;
7701         snprintf(symboln, sizeof(symboln), "%sTexBumpParameterfvATI", symbol_prefix);
7702         *procp = dlsym(handle, symboln);
7703     }
7704
7705
7706     if(!disp->TexBumpParameterivATI) {
7707         void ** procp = (void **) &disp->TexBumpParameterivATI;
7708         snprintf(symboln, sizeof(symboln), "%sTexBumpParameterivATI", symbol_prefix);
7709         *procp = dlsym(handle, symboln);
7710     }
7711
7712
7713     if(!disp->AlphaFragmentOp1ATI) {
7714         void ** procp = (void **) &disp->AlphaFragmentOp1ATI;
7715         snprintf(symboln, sizeof(symboln), "%sAlphaFragmentOp1ATI", symbol_prefix);
7716         *procp = dlsym(handle, symboln);
7717     }
7718
7719
7720     if(!disp->AlphaFragmentOp2ATI) {
7721         void ** procp = (void **) &disp->AlphaFragmentOp2ATI;
7722         snprintf(symboln, sizeof(symboln), "%sAlphaFragmentOp2ATI", symbol_prefix);
7723         *procp = dlsym(handle, symboln);
7724     }
7725
7726
7727     if(!disp->AlphaFragmentOp3ATI) {
7728         void ** procp = (void **) &disp->AlphaFragmentOp3ATI;
7729         snprintf(symboln, sizeof(symboln), "%sAlphaFragmentOp3ATI", symbol_prefix);
7730         *procp = dlsym(handle, symboln);
7731     }
7732
7733
7734     if(!disp->BeginFragmentShaderATI) {
7735         void ** procp = (void **) &disp->BeginFragmentShaderATI;
7736         snprintf(symboln, sizeof(symboln), "%sBeginFragmentShaderATI", symbol_prefix);
7737         *procp = dlsym(handle, symboln);
7738     }
7739
7740
7741     if(!disp->BindFragmentShaderATI) {
7742         void ** procp = (void **) &disp->BindFragmentShaderATI;
7743         snprintf(symboln, sizeof(symboln), "%sBindFragmentShaderATI", symbol_prefix);
7744         *procp = dlsym(handle, symboln);
7745     }
7746
7747
7748     if(!disp->ColorFragmentOp1ATI) {
7749         void ** procp = (void **) &disp->ColorFragmentOp1ATI;
7750         snprintf(symboln, sizeof(symboln), "%sColorFragmentOp1ATI", symbol_prefix);
7751         *procp = dlsym(handle, symboln);
7752     }
7753
7754
7755     if(!disp->ColorFragmentOp2ATI) {
7756         void ** procp = (void **) &disp->ColorFragmentOp2ATI;
7757         snprintf(symboln, sizeof(symboln), "%sColorFragmentOp2ATI", symbol_prefix);
7758         *procp = dlsym(handle, symboln);
7759     }
7760
7761
7762     if(!disp->ColorFragmentOp3ATI) {
7763         void ** procp = (void **) &disp->ColorFragmentOp3ATI;
7764         snprintf(symboln, sizeof(symboln), "%sColorFragmentOp3ATI", symbol_prefix);
7765         *procp = dlsym(handle, symboln);
7766     }
7767
7768
7769     if(!disp->DeleteFragmentShaderATI) {
7770         void ** procp = (void **) &disp->DeleteFragmentShaderATI;
7771         snprintf(symboln, sizeof(symboln), "%sDeleteFragmentShaderATI", symbol_prefix);
7772         *procp = dlsym(handle, symboln);
7773     }
7774
7775
7776     if(!disp->EndFragmentShaderATI) {
7777         void ** procp = (void **) &disp->EndFragmentShaderATI;
7778         snprintf(symboln, sizeof(symboln), "%sEndFragmentShaderATI", symbol_prefix);
7779         *procp = dlsym(handle, symboln);
7780     }
7781
7782
7783     if(!disp->GenFragmentShadersATI) {
7784         void ** procp = (void **) &disp->GenFragmentShadersATI;
7785         snprintf(symboln, sizeof(symboln), "%sGenFragmentShadersATI", symbol_prefix);
7786         *procp = dlsym(handle, symboln);
7787     }
7788
7789
7790     if(!disp->PassTexCoordATI) {
7791         void ** procp = (void **) &disp->PassTexCoordATI;
7792         snprintf(symboln, sizeof(symboln), "%sPassTexCoordATI", symbol_prefix);
7793         *procp = dlsym(handle, symboln);
7794     }
7795
7796
7797     if(!disp->SampleMapATI) {
7798         void ** procp = (void **) &disp->SampleMapATI;
7799         snprintf(symboln, sizeof(symboln), "%sSampleMapATI", symbol_prefix);
7800         *procp = dlsym(handle, symboln);
7801     }
7802
7803
7804     if(!disp->SetFragmentShaderConstantATI) {
7805         void ** procp = (void **) &disp->SetFragmentShaderConstantATI;
7806         snprintf(symboln, sizeof(symboln), "%sSetFragmentShaderConstantATI", symbol_prefix);
7807         *procp = dlsym(handle, symboln);
7808     }
7809
7810
7811     if(!disp->PointParameteriNV) {
7812         void ** procp = (void **) &disp->PointParameteriNV;
7813         snprintf(symboln, sizeof(symboln), "%sPointParameteri", symbol_prefix);
7814         *procp = dlsym(handle, symboln);
7815     }
7816
7817
7818     if(!disp->PointParameteriNV) {
7819         void ** procp = (void **) &disp->PointParameteriNV;
7820         snprintf(symboln, sizeof(symboln), "%sPointParameteriNV", symbol_prefix);
7821         *procp = dlsym(handle, symboln);
7822     }
7823
7824
7825     if(!disp->PointParameterivNV) {
7826         void ** procp = (void **) &disp->PointParameterivNV;
7827         snprintf(symboln, sizeof(symboln), "%sPointParameteriv", symbol_prefix);
7828         *procp = dlsym(handle, symboln);
7829     }
7830
7831
7832     if(!disp->PointParameterivNV) {
7833         void ** procp = (void **) &disp->PointParameterivNV;
7834         snprintf(symboln, sizeof(symboln), "%sPointParameterivNV", symbol_prefix);
7835         *procp = dlsym(handle, symboln);
7836     }
7837
7838
7839     if(!disp->ActiveStencilFaceEXT) {
7840         void ** procp = (void **) &disp->ActiveStencilFaceEXT;
7841         snprintf(symboln, sizeof(symboln), "%sActiveStencilFaceEXT", symbol_prefix);
7842         *procp = dlsym(handle, symboln);
7843     }
7844
7845
7846     if(!disp->BindVertexArrayAPPLE) {
7847         void ** procp = (void **) &disp->BindVertexArrayAPPLE;
7848         snprintf(symboln, sizeof(symboln), "%sBindVertexArrayAPPLE", symbol_prefix);
7849         *procp = dlsym(handle, symboln);
7850     }
7851
7852
7853     if(!disp->DeleteVertexArraysAPPLE) {
7854         void ** procp = (void **) &disp->DeleteVertexArraysAPPLE;
7855         snprintf(symboln, sizeof(symboln), "%sDeleteVertexArrays", symbol_prefix);
7856         *procp = dlsym(handle, symboln);
7857     }
7858
7859
7860     if(!disp->DeleteVertexArraysAPPLE) {
7861         void ** procp = (void **) &disp->DeleteVertexArraysAPPLE;
7862         snprintf(symboln, sizeof(symboln), "%sDeleteVertexArraysAPPLE", symbol_prefix);
7863         *procp = dlsym(handle, symboln);
7864     }
7865
7866
7867     if(!disp->GenVertexArraysAPPLE) {
7868         void ** procp = (void **) &disp->GenVertexArraysAPPLE;
7869         snprintf(symboln, sizeof(symboln), "%sGenVertexArraysAPPLE", symbol_prefix);
7870         *procp = dlsym(handle, symboln);
7871     }
7872
7873
7874     if(!disp->IsVertexArrayAPPLE) {
7875         void ** procp = (void **) &disp->IsVertexArrayAPPLE;
7876         snprintf(symboln, sizeof(symboln), "%sIsVertexArray", symbol_prefix);
7877         *procp = dlsym(handle, symboln);
7878     }
7879
7880
7881     if(!disp->IsVertexArrayAPPLE) {
7882         void ** procp = (void **) &disp->IsVertexArrayAPPLE;
7883         snprintf(symboln, sizeof(symboln), "%sIsVertexArrayAPPLE", symbol_prefix);
7884         *procp = dlsym(handle, symboln);
7885     }
7886
7887
7888     if(!disp->GetProgramNamedParameterdvNV) {
7889         void ** procp = (void **) &disp->GetProgramNamedParameterdvNV;
7890         snprintf(symboln, sizeof(symboln), "%sGetProgramNamedParameterdvNV", symbol_prefix);
7891         *procp = dlsym(handle, symboln);
7892     }
7893
7894
7895     if(!disp->GetProgramNamedParameterfvNV) {
7896         void ** procp = (void **) &disp->GetProgramNamedParameterfvNV;
7897         snprintf(symboln, sizeof(symboln), "%sGetProgramNamedParameterfvNV", symbol_prefix);
7898         *procp = dlsym(handle, symboln);
7899     }
7900
7901
7902     if(!disp->ProgramNamedParameter4dNV) {
7903         void ** procp = (void **) &disp->ProgramNamedParameter4dNV;
7904         snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4dNV", symbol_prefix);
7905         *procp = dlsym(handle, symboln);
7906     }
7907
7908
7909     if(!disp->ProgramNamedParameter4dvNV) {
7910         void ** procp = (void **) &disp->ProgramNamedParameter4dvNV;
7911         snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4dvNV", symbol_prefix);
7912         *procp = dlsym(handle, symboln);
7913     }
7914
7915
7916     if(!disp->ProgramNamedParameter4fNV) {
7917         void ** procp = (void **) &disp->ProgramNamedParameter4fNV;
7918         snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4fNV", symbol_prefix);
7919         *procp = dlsym(handle, symboln);
7920     }
7921
7922
7923     if(!disp->ProgramNamedParameter4fvNV) {
7924         void ** procp = (void **) &disp->ProgramNamedParameter4fvNV;
7925         snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4fvNV", symbol_prefix);
7926         *procp = dlsym(handle, symboln);
7927     }
7928
7929
7930     if(!disp->PrimitiveRestartIndexNV) {
7931         void ** procp = (void **) &disp->PrimitiveRestartIndexNV;
7932         snprintf(symboln, sizeof(symboln), "%sPrimitiveRestartIndexNV", symbol_prefix);
7933         *procp = dlsym(handle, symboln);
7934     }
7935
7936
7937     if(!disp->PrimitiveRestartIndexNV) {
7938         void ** procp = (void **) &disp->PrimitiveRestartIndexNV;
7939         snprintf(symboln, sizeof(symboln), "%sPrimitiveRestartIndex", symbol_prefix);
7940         *procp = dlsym(handle, symboln);
7941     }
7942
7943
7944     if(!disp->PrimitiveRestartNV) {
7945         void ** procp = (void **) &disp->PrimitiveRestartNV;
7946         snprintf(symboln, sizeof(symboln), "%sPrimitiveRestartNV", symbol_prefix);
7947         *procp = dlsym(handle, symboln);
7948     }
7949
7950
7951     if(!disp->DepthBoundsEXT) {
7952         void ** procp = (void **) &disp->DepthBoundsEXT;
7953         snprintf(symboln, sizeof(symboln), "%sDepthBoundsEXT", symbol_prefix);
7954         *procp = dlsym(handle, symboln);
7955     }
7956
7957
7958     if(!disp->BlendEquationSeparateEXT) {
7959         void ** procp = (void **) &disp->BlendEquationSeparateEXT;
7960         snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparate", symbol_prefix);
7961         *procp = dlsym(handle, symboln);
7962     }
7963
7964
7965     if(!disp->BlendEquationSeparateEXT) {
7966         void ** procp = (void **) &disp->BlendEquationSeparateEXT;
7967         snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateEXT", symbol_prefix);
7968         *procp = dlsym(handle, symboln);
7969     }
7970
7971
7972     if(!disp->BlendEquationSeparateEXT) {
7973         void ** procp = (void **) &disp->BlendEquationSeparateEXT;
7974         snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateATI", symbol_prefix);
7975         *procp = dlsym(handle, symboln);
7976     }
7977
7978
7979     if(!disp->BindFramebufferEXT) {
7980         void ** procp = (void **) &disp->BindFramebufferEXT;
7981         snprintf(symboln, sizeof(symboln), "%sBindFramebuffer", symbol_prefix);
7982         *procp = dlsym(handle, symboln);
7983     }
7984
7985
7986     if(!disp->BindFramebufferEXT) {
7987         void ** procp = (void **) &disp->BindFramebufferEXT;
7988         snprintf(symboln, sizeof(symboln), "%sBindFramebufferEXT", symbol_prefix);
7989         *procp = dlsym(handle, symboln);
7990     }
7991
7992
7993     if(!disp->BindRenderbufferEXT) {
7994         void ** procp = (void **) &disp->BindRenderbufferEXT;
7995         snprintf(symboln, sizeof(symboln), "%sBindRenderbuffer", symbol_prefix);
7996         *procp = dlsym(handle, symboln);
7997     }
7998
7999
8000     if(!disp->BindRenderbufferEXT) {
8001         void ** procp = (void **) &disp->BindRenderbufferEXT;
8002         snprintf(symboln, sizeof(symboln), "%sBindRenderbufferEXT", symbol_prefix);
8003         *procp = dlsym(handle, symboln);
8004     }
8005
8006
8007     if(!disp->CheckFramebufferStatusEXT) {
8008         void ** procp = (void **) &disp->CheckFramebufferStatusEXT;
8009         snprintf(symboln, sizeof(symboln), "%sCheckFramebufferStatus", symbol_prefix);
8010         *procp = dlsym(handle, symboln);
8011     }
8012
8013
8014     if(!disp->CheckFramebufferStatusEXT) {
8015         void ** procp = (void **) &disp->CheckFramebufferStatusEXT;
8016         snprintf(symboln, sizeof(symboln), "%sCheckFramebufferStatusEXT", symbol_prefix);
8017         *procp = dlsym(handle, symboln);
8018     }
8019
8020
8021     if(!disp->DeleteFramebuffersEXT) {
8022         void ** procp = (void **) &disp->DeleteFramebuffersEXT;
8023         snprintf(symboln, sizeof(symboln), "%sDeleteFramebuffers", symbol_prefix);
8024         *procp = dlsym(handle, symboln);
8025     }
8026
8027
8028     if(!disp->DeleteFramebuffersEXT) {
8029         void ** procp = (void **) &disp->DeleteFramebuffersEXT;
8030         snprintf(symboln, sizeof(symboln), "%sDeleteFramebuffersEXT", symbol_prefix);
8031         *procp = dlsym(handle, symboln);
8032     }
8033
8034
8035     if(!disp->DeleteRenderbuffersEXT) {
8036         void ** procp = (void **) &disp->DeleteRenderbuffersEXT;
8037         snprintf(symboln, sizeof(symboln), "%sDeleteRenderbuffers", symbol_prefix);
8038         *procp = dlsym(handle, symboln);
8039     }
8040
8041
8042     if(!disp->DeleteRenderbuffersEXT) {
8043         void ** procp = (void **) &disp->DeleteRenderbuffersEXT;
8044         snprintf(symboln, sizeof(symboln), "%sDeleteRenderbuffersEXT", symbol_prefix);
8045         *procp = dlsym(handle, symboln);
8046     }
8047
8048
8049     if(!disp->FramebufferRenderbufferEXT) {
8050         void ** procp = (void **) &disp->FramebufferRenderbufferEXT;
8051         snprintf(symboln, sizeof(symboln), "%sFramebufferRenderbuffer", symbol_prefix);
8052         *procp = dlsym(handle, symboln);
8053     }
8054
8055
8056     if(!disp->FramebufferRenderbufferEXT) {
8057         void ** procp = (void **) &disp->FramebufferRenderbufferEXT;
8058         snprintf(symboln, sizeof(symboln), "%sFramebufferRenderbufferEXT", symbol_prefix);
8059         *procp = dlsym(handle, symboln);
8060     }
8061
8062
8063     if(!disp->FramebufferTexture1DEXT) {
8064         void ** procp = (void **) &disp->FramebufferTexture1DEXT;
8065         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture1D", symbol_prefix);
8066         *procp = dlsym(handle, symboln);
8067     }
8068
8069
8070     if(!disp->FramebufferTexture1DEXT) {
8071         void ** procp = (void **) &disp->FramebufferTexture1DEXT;
8072         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture1DEXT", symbol_prefix);
8073         *procp = dlsym(handle, symboln);
8074     }
8075
8076
8077     if(!disp->FramebufferTexture2DEXT) {
8078         void ** procp = (void **) &disp->FramebufferTexture2DEXT;
8079         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture2D", symbol_prefix);
8080         *procp = dlsym(handle, symboln);
8081     }
8082
8083
8084     if(!disp->FramebufferTexture2DEXT) {
8085         void ** procp = (void **) &disp->FramebufferTexture2DEXT;
8086         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture2DEXT", symbol_prefix);
8087         *procp = dlsym(handle, symboln);
8088     }
8089
8090
8091     if(!disp->FramebufferTexture3DEXT) {
8092         void ** procp = (void **) &disp->FramebufferTexture3DEXT;
8093         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture3D", symbol_prefix);
8094         *procp = dlsym(handle, symboln);
8095     }
8096
8097
8098     if(!disp->FramebufferTexture3DEXT) {
8099         void ** procp = (void **) &disp->FramebufferTexture3DEXT;
8100         snprintf(symboln, sizeof(symboln), "%sFramebufferTexture3DEXT", symbol_prefix);
8101         *procp = dlsym(handle, symboln);
8102     }
8103
8104
8105     if(!disp->GenFramebuffersEXT) {
8106         void ** procp = (void **) &disp->GenFramebuffersEXT;
8107         snprintf(symboln, sizeof(symboln), "%sGenFramebuffers", symbol_prefix);
8108         *procp = dlsym(handle, symboln);
8109     }
8110
8111
8112     if(!disp->GenFramebuffersEXT) {
8113         void ** procp = (void **) &disp->GenFramebuffersEXT;
8114         snprintf(symboln, sizeof(symboln), "%sGenFramebuffersEXT", symbol_prefix);
8115         *procp = dlsym(handle, symboln);
8116     }
8117
8118
8119     if(!disp->GenRenderbuffersEXT) {
8120         void ** procp = (void **) &disp->GenRenderbuffersEXT;
8121         snprintf(symboln, sizeof(symboln), "%sGenRenderbuffers", symbol_prefix);
8122         *procp = dlsym(handle, symboln);
8123     }
8124
8125
8126     if(!disp->GenRenderbuffersEXT) {
8127         void ** procp = (void **) &disp->GenRenderbuffersEXT;
8128         snprintf(symboln, sizeof(symboln), "%sGenRenderbuffersEXT", symbol_prefix);
8129         *procp = dlsym(handle, symboln);
8130     }
8131
8132
8133     if(!disp->GenerateMipmapEXT) {
8134         void ** procp = (void **) &disp->GenerateMipmapEXT;
8135         snprintf(symboln, sizeof(symboln), "%sGenerateMipmap", symbol_prefix);
8136         *procp = dlsym(handle, symboln);
8137     }
8138
8139
8140     if(!disp->GenerateMipmapEXT) {
8141         void ** procp = (void **) &disp->GenerateMipmapEXT;
8142         snprintf(symboln, sizeof(symboln), "%sGenerateMipmapEXT", symbol_prefix);
8143         *procp = dlsym(handle, symboln);
8144     }
8145
8146
8147     if(!disp->GetFramebufferAttachmentParameterivEXT) {
8148         void ** procp = (void **) &disp->GetFramebufferAttachmentParameterivEXT;
8149         snprintf(symboln, sizeof(symboln), "%sGetFramebufferAttachmentParameteriv", symbol_prefix);
8150         *procp = dlsym(handle, symboln);
8151     }
8152
8153
8154     if(!disp->GetFramebufferAttachmentParameterivEXT) {
8155         void ** procp = (void **) &disp->GetFramebufferAttachmentParameterivEXT;
8156         snprintf(symboln, sizeof(symboln), "%sGetFramebufferAttachmentParameterivEXT", symbol_prefix);
8157         *procp = dlsym(handle, symboln);
8158     }
8159
8160
8161     if(!disp->GetRenderbufferParameterivEXT) {
8162         void ** procp = (void **) &disp->GetRenderbufferParameterivEXT;
8163         snprintf(symboln, sizeof(symboln), "%sGetRenderbufferParameteriv", symbol_prefix);
8164         *procp = dlsym(handle, symboln);
8165     }
8166
8167
8168     if(!disp->GetRenderbufferParameterivEXT) {
8169         void ** procp = (void **) &disp->GetRenderbufferParameterivEXT;
8170         snprintf(symboln, sizeof(symboln), "%sGetRenderbufferParameterivEXT", symbol_prefix);
8171         *procp = dlsym(handle, symboln);
8172     }
8173
8174
8175     if(!disp->IsFramebufferEXT) {
8176         void ** procp = (void **) &disp->IsFramebufferEXT;
8177         snprintf(symboln, sizeof(symboln), "%sIsFramebuffer", symbol_prefix);
8178         *procp = dlsym(handle, symboln);
8179     }
8180
8181
8182     if(!disp->IsFramebufferEXT) {
8183         void ** procp = (void **) &disp->IsFramebufferEXT;
8184         snprintf(symboln, sizeof(symboln), "%sIsFramebufferEXT", symbol_prefix);
8185         *procp = dlsym(handle, symboln);
8186     }
8187
8188
8189     if(!disp->IsRenderbufferEXT) {
8190         void ** procp = (void **) &disp->IsRenderbufferEXT;
8191         snprintf(symboln, sizeof(symboln), "%sIsRenderbuffer", symbol_prefix);
8192         *procp = dlsym(handle, symboln);
8193     }
8194
8195
8196     if(!disp->IsRenderbufferEXT) {
8197         void ** procp = (void **) &disp->IsRenderbufferEXT;
8198         snprintf(symboln, sizeof(symboln), "%sIsRenderbufferEXT", symbol_prefix);
8199         *procp = dlsym(handle, symboln);
8200     }
8201
8202
8203     if(!disp->RenderbufferStorageEXT) {
8204         void ** procp = (void **) &disp->RenderbufferStorageEXT;
8205         snprintf(symboln, sizeof(symboln), "%sRenderbufferStorage", symbol_prefix);
8206         *procp = dlsym(handle, symboln);
8207     }
8208
8209
8210     if(!disp->RenderbufferStorageEXT) {
8211         void ** procp = (void **) &disp->RenderbufferStorageEXT;
8212         snprintf(symboln, sizeof(symboln), "%sRenderbufferStorageEXT", symbol_prefix);
8213         *procp = dlsym(handle, symboln);
8214     }
8215
8216
8217     if(!disp->BlitFramebufferEXT) {
8218         void ** procp = (void **) &disp->BlitFramebufferEXT;
8219         snprintf(symboln, sizeof(symboln), "%sBlitFramebuffer", symbol_prefix);
8220         *procp = dlsym(handle, symboln);
8221     }
8222
8223
8224     if(!disp->BlitFramebufferEXT) {
8225         void ** procp = (void **) &disp->BlitFramebufferEXT;
8226         snprintf(symboln, sizeof(symboln), "%sBlitFramebufferEXT", symbol_prefix);
8227         *procp = dlsym(handle, symboln);
8228     }
8229
8230
8231     if(!disp->BufferParameteriAPPLE) {
8232         void ** procp = (void **) &disp->BufferParameteriAPPLE;
8233         snprintf(symboln, sizeof(symboln), "%sBufferParameteriAPPLE", symbol_prefix);
8234         *procp = dlsym(handle, symboln);
8235     }
8236
8237
8238     if(!disp->FlushMappedBufferRangeAPPLE) {
8239         void ** procp = (void **) &disp->FlushMappedBufferRangeAPPLE;
8240         snprintf(symboln, sizeof(symboln), "%sFlushMappedBufferRangeAPPLE", symbol_prefix);
8241         *procp = dlsym(handle, symboln);
8242     }
8243
8244
8245     if(!disp->BindFragDataLocationEXT) {
8246         void ** procp = (void **) &disp->BindFragDataLocationEXT;
8247         snprintf(symboln, sizeof(symboln), "%sBindFragDataLocationEXT", symbol_prefix);
8248         *procp = dlsym(handle, symboln);
8249     }
8250
8251
8252     if(!disp->BindFragDataLocationEXT) {
8253         void ** procp = (void **) &disp->BindFragDataLocationEXT;
8254         snprintf(symboln, sizeof(symboln), "%sBindFragDataLocation", symbol_prefix);
8255         *procp = dlsym(handle, symboln);
8256     }
8257
8258
8259     if(!disp->GetFragDataLocationEXT) {
8260         void ** procp = (void **) &disp->GetFragDataLocationEXT;
8261         snprintf(symboln, sizeof(symboln), "%sGetFragDataLocationEXT", symbol_prefix);
8262         *procp = dlsym(handle, symboln);
8263     }
8264
8265
8266     if(!disp->GetFragDataLocationEXT) {
8267         void ** procp = (void **) &disp->GetFragDataLocationEXT;
8268         snprintf(symboln, sizeof(symboln), "%sGetFragDataLocation", symbol_prefix);
8269         *procp = dlsym(handle, symboln);
8270     }
8271
8272
8273     if(!disp->GetUniformuivEXT) {
8274         void ** procp = (void **) &disp->GetUniformuivEXT;
8275         snprintf(symboln, sizeof(symboln), "%sGetUniformuivEXT", symbol_prefix);
8276         *procp = dlsym(handle, symboln);
8277     }
8278
8279
8280     if(!disp->GetUniformuivEXT) {
8281         void ** procp = (void **) &disp->GetUniformuivEXT;
8282         snprintf(symboln, sizeof(symboln), "%sGetUniformuiv", symbol_prefix);
8283         *procp = dlsym(handle, symboln);
8284     }
8285
8286
8287     if(!disp->GetVertexAttribIivEXT) {
8288         void ** procp = (void **) &disp->GetVertexAttribIivEXT;
8289         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIivEXT", symbol_prefix);
8290         *procp = dlsym(handle, symboln);
8291     }
8292
8293
8294     if(!disp->GetVertexAttribIivEXT) {
8295         void ** procp = (void **) &disp->GetVertexAttribIivEXT;
8296         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIiv", symbol_prefix);
8297         *procp = dlsym(handle, symboln);
8298     }
8299
8300
8301     if(!disp->GetVertexAttribIuivEXT) {
8302         void ** procp = (void **) &disp->GetVertexAttribIuivEXT;
8303         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIuivEXT", symbol_prefix);
8304         *procp = dlsym(handle, symboln);
8305     }
8306
8307
8308     if(!disp->GetVertexAttribIuivEXT) {
8309         void ** procp = (void **) &disp->GetVertexAttribIuivEXT;
8310         snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIuiv", symbol_prefix);
8311         *procp = dlsym(handle, symboln);
8312     }
8313
8314
8315     if(!disp->Uniform1uiEXT) {
8316         void ** procp = (void **) &disp->Uniform1uiEXT;
8317         snprintf(symboln, sizeof(symboln), "%sUniform1uiEXT", symbol_prefix);
8318         *procp = dlsym(handle, symboln);
8319     }
8320
8321
8322     if(!disp->Uniform1uiEXT) {
8323         void ** procp = (void **) &disp->Uniform1uiEXT;
8324         snprintf(symboln, sizeof(symboln), "%sUniform1ui", symbol_prefix);
8325         *procp = dlsym(handle, symboln);
8326     }
8327
8328
8329     if(!disp->Uniform1uivEXT) {
8330         void ** procp = (void **) &disp->Uniform1uivEXT;
8331         snprintf(symboln, sizeof(symboln), "%sUniform1uivEXT", symbol_prefix);
8332         *procp = dlsym(handle, symboln);
8333     }
8334
8335
8336     if(!disp->Uniform1uivEXT) {
8337         void ** procp = (void **) &disp->Uniform1uivEXT;
8338         snprintf(symboln, sizeof(symboln), "%sUniform1uiv", symbol_prefix);
8339         *procp = dlsym(handle, symboln);
8340     }
8341
8342
8343     if(!disp->Uniform2uiEXT) {
8344         void ** procp = (void **) &disp->Uniform2uiEXT;
8345         snprintf(symboln, sizeof(symboln), "%sUniform2uiEXT", symbol_prefix);
8346         *procp = dlsym(handle, symboln);
8347     }
8348
8349
8350     if(!disp->Uniform2uiEXT) {
8351         void ** procp = (void **) &disp->Uniform2uiEXT;
8352         snprintf(symboln, sizeof(symboln), "%sUniform2ui", symbol_prefix);
8353         *procp = dlsym(handle, symboln);
8354     }
8355
8356
8357     if(!disp->Uniform2uivEXT) {
8358         void ** procp = (void **) &disp->Uniform2uivEXT;
8359         snprintf(symboln, sizeof(symboln), "%sUniform2uivEXT", symbol_prefix);
8360         *procp = dlsym(handle, symboln);
8361     }
8362
8363
8364     if(!disp->Uniform2uivEXT) {
8365         void ** procp = (void **) &disp->Uniform2uivEXT;
8366         snprintf(symboln, sizeof(symboln), "%sUniform2uiv", symbol_prefix);
8367         *procp = dlsym(handle, symboln);
8368     }
8369
8370
8371     if(!disp->Uniform3uiEXT) {
8372         void ** procp = (void **) &disp->Uniform3uiEXT;
8373         snprintf(symboln, sizeof(symboln), "%sUniform3uiEXT", symbol_prefix);
8374         *procp = dlsym(handle, symboln);
8375     }
8376
8377
8378     if(!disp->Uniform3uiEXT) {
8379         void ** procp = (void **) &disp->Uniform3uiEXT;
8380         snprintf(symboln, sizeof(symboln), "%sUniform3ui", symbol_prefix);
8381         *procp = dlsym(handle, symboln);
8382     }
8383
8384
8385     if(!disp->Uniform3uivEXT) {
8386         void ** procp = (void **) &disp->Uniform3uivEXT;
8387         snprintf(symboln, sizeof(symboln), "%sUniform3uivEXT", symbol_prefix);
8388         *procp = dlsym(handle, symboln);
8389     }
8390
8391
8392     if(!disp->Uniform3uivEXT) {
8393         void ** procp = (void **) &disp->Uniform3uivEXT;
8394         snprintf(symboln, sizeof(symboln), "%sUniform3uiv", symbol_prefix);
8395         *procp = dlsym(handle, symboln);
8396     }
8397
8398
8399     if(!disp->Uniform4uiEXT) {
8400         void ** procp = (void **) &disp->Uniform4uiEXT;
8401         snprintf(symboln, sizeof(symboln), "%sUniform4uiEXT", symbol_prefix);
8402         *procp = dlsym(handle, symboln);
8403     }
8404
8405
8406     if(!disp->Uniform4uiEXT) {
8407         void ** procp = (void **) &disp->Uniform4uiEXT;
8408         snprintf(symboln, sizeof(symboln), "%sUniform4ui", symbol_prefix);
8409         *procp = dlsym(handle, symboln);
8410     }
8411
8412
8413     if(!disp->Uniform4uivEXT) {
8414         void ** procp = (void **) &disp->Uniform4uivEXT;
8415         snprintf(symboln, sizeof(symboln), "%sUniform4uivEXT", symbol_prefix);
8416         *procp = dlsym(handle, symboln);
8417     }
8418
8419
8420     if(!disp->Uniform4uivEXT) {
8421         void ** procp = (void **) &disp->Uniform4uivEXT;
8422         snprintf(symboln, sizeof(symboln), "%sUniform4uiv", symbol_prefix);
8423         *procp = dlsym(handle, symboln);
8424     }
8425
8426
8427     if(!disp->VertexAttribI1iEXT) {
8428         void ** procp = (void **) &disp->VertexAttribI1iEXT;
8429         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1iEXT", symbol_prefix);
8430         *procp = dlsym(handle, symboln);
8431     }
8432
8433
8434     if(!disp->VertexAttribI1iEXT) {
8435         void ** procp = (void **) &disp->VertexAttribI1iEXT;
8436         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1i", symbol_prefix);
8437         *procp = dlsym(handle, symboln);
8438     }
8439
8440
8441     if(!disp->VertexAttribI1ivEXT) {
8442         void ** procp = (void **) &disp->VertexAttribI1ivEXT;
8443         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1ivEXT", symbol_prefix);
8444         *procp = dlsym(handle, symboln);
8445     }
8446
8447
8448     if(!disp->VertexAttribI1ivEXT) {
8449         void ** procp = (void **) &disp->VertexAttribI1ivEXT;
8450         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1iv", symbol_prefix);
8451         *procp = dlsym(handle, symboln);
8452     }
8453
8454
8455     if(!disp->VertexAttribI1uiEXT) {
8456         void ** procp = (void **) &disp->VertexAttribI1uiEXT;
8457         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1uiEXT", symbol_prefix);
8458         *procp = dlsym(handle, symboln);
8459     }
8460
8461
8462     if(!disp->VertexAttribI1uiEXT) {
8463         void ** procp = (void **) &disp->VertexAttribI1uiEXT;
8464         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1ui", symbol_prefix);
8465         *procp = dlsym(handle, symboln);
8466     }
8467
8468
8469     if(!disp->VertexAttribI1uivEXT) {
8470         void ** procp = (void **) &disp->VertexAttribI1uivEXT;
8471         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1uivEXT", symbol_prefix);
8472         *procp = dlsym(handle, symboln);
8473     }
8474
8475
8476     if(!disp->VertexAttribI1uivEXT) {
8477         void ** procp = (void **) &disp->VertexAttribI1uivEXT;
8478         snprintf(symboln, sizeof(symboln), "%sVertexAttribI1uiv", symbol_prefix);
8479         *procp = dlsym(handle, symboln);
8480     }
8481
8482
8483     if(!disp->VertexAttribI2iEXT) {
8484         void ** procp = (void **) &disp->VertexAttribI2iEXT;
8485         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2iEXT", symbol_prefix);
8486         *procp = dlsym(handle, symboln);
8487     }
8488
8489
8490     if(!disp->VertexAttribI2iEXT) {
8491         void ** procp = (void **) &disp->VertexAttribI2iEXT;
8492         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2i", symbol_prefix);
8493         *procp = dlsym(handle, symboln);
8494     }
8495
8496
8497     if(!disp->VertexAttribI2ivEXT) {
8498         void ** procp = (void **) &disp->VertexAttribI2ivEXT;
8499         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2ivEXT", symbol_prefix);
8500         *procp = dlsym(handle, symboln);
8501     }
8502
8503
8504     if(!disp->VertexAttribI2ivEXT) {
8505         void ** procp = (void **) &disp->VertexAttribI2ivEXT;
8506         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2iv", symbol_prefix);
8507         *procp = dlsym(handle, symboln);
8508     }
8509
8510
8511     if(!disp->VertexAttribI2uiEXT) {
8512         void ** procp = (void **) &disp->VertexAttribI2uiEXT;
8513         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2uiEXT", symbol_prefix);
8514         *procp = dlsym(handle, symboln);
8515     }
8516
8517
8518     if(!disp->VertexAttribI2uiEXT) {
8519         void ** procp = (void **) &disp->VertexAttribI2uiEXT;
8520         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2ui", symbol_prefix);
8521         *procp = dlsym(handle, symboln);
8522     }
8523
8524
8525     if(!disp->VertexAttribI2uivEXT) {
8526         void ** procp = (void **) &disp->VertexAttribI2uivEXT;
8527         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2uivEXT", symbol_prefix);
8528         *procp = dlsym(handle, symboln);
8529     }
8530
8531
8532     if(!disp->VertexAttribI2uivEXT) {
8533         void ** procp = (void **) &disp->VertexAttribI2uivEXT;
8534         snprintf(symboln, sizeof(symboln), "%sVertexAttribI2uiv", symbol_prefix);
8535         *procp = dlsym(handle, symboln);
8536     }
8537
8538
8539     if(!disp->VertexAttribI3iEXT) {
8540         void ** procp = (void **) &disp->VertexAttribI3iEXT;
8541         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3iEXT", symbol_prefix);
8542         *procp = dlsym(handle, symboln);
8543     }
8544
8545
8546     if(!disp->VertexAttribI3iEXT) {
8547         void ** procp = (void **) &disp->VertexAttribI3iEXT;
8548         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3i", symbol_prefix);
8549         *procp = dlsym(handle, symboln);
8550     }
8551
8552
8553     if(!disp->VertexAttribI3ivEXT) {
8554         void ** procp = (void **) &disp->VertexAttribI3ivEXT;
8555         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3ivEXT", symbol_prefix);
8556         *procp = dlsym(handle, symboln);
8557     }
8558
8559
8560     if(!disp->VertexAttribI3ivEXT) {
8561         void ** procp = (void **) &disp->VertexAttribI3ivEXT;
8562         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3iv", symbol_prefix);
8563         *procp = dlsym(handle, symboln);
8564     }
8565
8566
8567     if(!disp->VertexAttribI3uiEXT) {
8568         void ** procp = (void **) &disp->VertexAttribI3uiEXT;
8569         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3uiEXT", symbol_prefix);
8570         *procp = dlsym(handle, symboln);
8571     }
8572
8573
8574     if(!disp->VertexAttribI3uiEXT) {
8575         void ** procp = (void **) &disp->VertexAttribI3uiEXT;
8576         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3ui", symbol_prefix);
8577         *procp = dlsym(handle, symboln);
8578     }
8579
8580
8581     if(!disp->VertexAttribI3uivEXT) {
8582         void ** procp = (void **) &disp->VertexAttribI3uivEXT;
8583         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3uivEXT", symbol_prefix);
8584         *procp = dlsym(handle, symboln);
8585     }
8586
8587
8588     if(!disp->VertexAttribI3uivEXT) {
8589         void ** procp = (void **) &disp->VertexAttribI3uivEXT;
8590         snprintf(symboln, sizeof(symboln), "%sVertexAttribI3uiv", symbol_prefix);
8591         *procp = dlsym(handle, symboln);
8592     }
8593
8594
8595     if(!disp->VertexAttribI4bvEXT) {
8596         void ** procp = (void **) &disp->VertexAttribI4bvEXT;
8597         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4bvEXT", symbol_prefix);
8598         *procp = dlsym(handle, symboln);
8599     }
8600
8601
8602     if(!disp->VertexAttribI4bvEXT) {
8603         void ** procp = (void **) &disp->VertexAttribI4bvEXT;
8604         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4bv", symbol_prefix);
8605         *procp = dlsym(handle, symboln);
8606     }
8607
8608
8609     if(!disp->VertexAttribI4iEXT) {
8610         void ** procp = (void **) &disp->VertexAttribI4iEXT;
8611         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4iEXT", symbol_prefix);
8612         *procp = dlsym(handle, symboln);
8613     }
8614
8615
8616     if(!disp->VertexAttribI4iEXT) {
8617         void ** procp = (void **) &disp->VertexAttribI4iEXT;
8618         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4i", symbol_prefix);
8619         *procp = dlsym(handle, symboln);
8620     }
8621
8622
8623     if(!disp->VertexAttribI4ivEXT) {
8624         void ** procp = (void **) &disp->VertexAttribI4ivEXT;
8625         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ivEXT", symbol_prefix);
8626         *procp = dlsym(handle, symboln);
8627     }
8628
8629
8630     if(!disp->VertexAttribI4ivEXT) {
8631         void ** procp = (void **) &disp->VertexAttribI4ivEXT;
8632         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4iv", symbol_prefix);
8633         *procp = dlsym(handle, symboln);
8634     }
8635
8636
8637     if(!disp->VertexAttribI4svEXT) {
8638         void ** procp = (void **) &disp->VertexAttribI4svEXT;
8639         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4svEXT", symbol_prefix);
8640         *procp = dlsym(handle, symboln);
8641     }
8642
8643
8644     if(!disp->VertexAttribI4svEXT) {
8645         void ** procp = (void **) &disp->VertexAttribI4svEXT;
8646         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4sv", symbol_prefix);
8647         *procp = dlsym(handle, symboln);
8648     }
8649
8650
8651     if(!disp->VertexAttribI4ubvEXT) {
8652         void ** procp = (void **) &disp->VertexAttribI4ubvEXT;
8653         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ubvEXT", symbol_prefix);
8654         *procp = dlsym(handle, symboln);
8655     }
8656
8657
8658     if(!disp->VertexAttribI4ubvEXT) {
8659         void ** procp = (void **) &disp->VertexAttribI4ubvEXT;
8660         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ubv", symbol_prefix);
8661         *procp = dlsym(handle, symboln);
8662     }
8663
8664
8665     if(!disp->VertexAttribI4uiEXT) {
8666         void ** procp = (void **) &disp->VertexAttribI4uiEXT;
8667         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4uiEXT", symbol_prefix);
8668         *procp = dlsym(handle, symboln);
8669     }
8670
8671
8672     if(!disp->VertexAttribI4uiEXT) {
8673         void ** procp = (void **) &disp->VertexAttribI4uiEXT;
8674         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ui", symbol_prefix);
8675         *procp = dlsym(handle, symboln);
8676     }
8677
8678
8679     if(!disp->VertexAttribI4uivEXT) {
8680         void ** procp = (void **) &disp->VertexAttribI4uivEXT;
8681         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4uivEXT", symbol_prefix);
8682         *procp = dlsym(handle, symboln);
8683     }
8684
8685
8686     if(!disp->VertexAttribI4uivEXT) {
8687         void ** procp = (void **) &disp->VertexAttribI4uivEXT;
8688         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4uiv", symbol_prefix);
8689         *procp = dlsym(handle, symboln);
8690     }
8691
8692
8693     if(!disp->VertexAttribI4usvEXT) {
8694         void ** procp = (void **) &disp->VertexAttribI4usvEXT;
8695         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4usvEXT", symbol_prefix);
8696         *procp = dlsym(handle, symboln);
8697     }
8698
8699
8700     if(!disp->VertexAttribI4usvEXT) {
8701         void ** procp = (void **) &disp->VertexAttribI4usvEXT;
8702         snprintf(symboln, sizeof(symboln), "%sVertexAttribI4usv", symbol_prefix);
8703         *procp = dlsym(handle, symboln);
8704     }
8705
8706
8707     if(!disp->VertexAttribIPointerEXT) {
8708         void ** procp = (void **) &disp->VertexAttribIPointerEXT;
8709         snprintf(symboln, sizeof(symboln), "%sVertexAttribIPointerEXT", symbol_prefix);
8710         *procp = dlsym(handle, symboln);
8711     }
8712
8713
8714     if(!disp->VertexAttribIPointerEXT) {
8715         void ** procp = (void **) &disp->VertexAttribIPointerEXT;
8716         snprintf(symboln, sizeof(symboln), "%sVertexAttribIPointer", symbol_prefix);
8717         *procp = dlsym(handle, symboln);
8718     }
8719
8720
8721     if(!disp->FramebufferTextureLayerEXT) {
8722         void ** procp = (void **) &disp->FramebufferTextureLayerEXT;
8723         snprintf(symboln, sizeof(symboln), "%sFramebufferTextureLayer", symbol_prefix);
8724         *procp = dlsym(handle, symboln);
8725     }
8726
8727
8728     if(!disp->FramebufferTextureLayerEXT) {
8729         void ** procp = (void **) &disp->FramebufferTextureLayerEXT;
8730         snprintf(symboln, sizeof(symboln), "%sFramebufferTextureLayerEXT", symbol_prefix);
8731         *procp = dlsym(handle, symboln);
8732     }
8733
8734
8735     if(!disp->ColorMaskIndexedEXT) {
8736         void ** procp = (void **) &disp->ColorMaskIndexedEXT;
8737         snprintf(symboln, sizeof(symboln), "%sColorMaskIndexedEXT", symbol_prefix);
8738         *procp = dlsym(handle, symboln);
8739     }
8740
8741
8742     if(!disp->ColorMaskIndexedEXT) {
8743         void ** procp = (void **) &disp->ColorMaskIndexedEXT;
8744         snprintf(symboln, sizeof(symboln), "%sColorMaski", symbol_prefix);
8745         *procp = dlsym(handle, symboln);
8746     }
8747
8748
8749     if(!disp->DisableIndexedEXT) {
8750         void ** procp = (void **) &disp->DisableIndexedEXT;
8751         snprintf(symboln, sizeof(symboln), "%sDisableIndexedEXT", symbol_prefix);
8752         *procp = dlsym(handle, symboln);
8753     }
8754
8755
8756     if(!disp->DisableIndexedEXT) {
8757         void ** procp = (void **) &disp->DisableIndexedEXT;
8758         snprintf(symboln, sizeof(symboln), "%sDisablei", symbol_prefix);
8759         *procp = dlsym(handle, symboln);
8760     }
8761
8762
8763     if(!disp->EnableIndexedEXT) {
8764         void ** procp = (void **) &disp->EnableIndexedEXT;
8765         snprintf(symboln, sizeof(symboln), "%sEnableIndexedEXT", symbol_prefix);
8766         *procp = dlsym(handle, symboln);
8767     }
8768
8769
8770     if(!disp->EnableIndexedEXT) {
8771         void ** procp = (void **) &disp->EnableIndexedEXT;
8772         snprintf(symboln, sizeof(symboln), "%sEnablei", symbol_prefix);
8773         *procp = dlsym(handle, symboln);
8774     }
8775
8776
8777     if(!disp->GetBooleanIndexedvEXT) {
8778         void ** procp = (void **) &disp->GetBooleanIndexedvEXT;
8779         snprintf(symboln, sizeof(symboln), "%sGetBooleanIndexedvEXT", symbol_prefix);
8780         *procp = dlsym(handle, symboln);
8781     }
8782
8783
8784     if(!disp->GetBooleanIndexedvEXT) {
8785         void ** procp = (void **) &disp->GetBooleanIndexedvEXT;
8786         snprintf(symboln, sizeof(symboln), "%sGetBooleani_v", symbol_prefix);
8787         *procp = dlsym(handle, symboln);
8788     }
8789
8790
8791     if(!disp->GetIntegerIndexedvEXT) {
8792         void ** procp = (void **) &disp->GetIntegerIndexedvEXT;
8793         snprintf(symboln, sizeof(symboln), "%sGetIntegerIndexedvEXT", symbol_prefix);
8794         *procp = dlsym(handle, symboln);
8795     }
8796
8797
8798     if(!disp->GetIntegerIndexedvEXT) {
8799         void ** procp = (void **) &disp->GetIntegerIndexedvEXT;
8800         snprintf(symboln, sizeof(symboln), "%sGetIntegeri_v", symbol_prefix);
8801         *procp = dlsym(handle, symboln);
8802     }
8803
8804
8805     if(!disp->IsEnabledIndexedEXT) {
8806         void ** procp = (void **) &disp->IsEnabledIndexedEXT;
8807         snprintf(symboln, sizeof(symboln), "%sIsEnabledIndexedEXT", symbol_prefix);
8808         *procp = dlsym(handle, symboln);
8809     }
8810
8811
8812     if(!disp->IsEnabledIndexedEXT) {
8813         void ** procp = (void **) &disp->IsEnabledIndexedEXT;
8814         snprintf(symboln, sizeof(symboln), "%sIsEnabledi", symbol_prefix);
8815         *procp = dlsym(handle, symboln);
8816     }
8817
8818
8819     if(!disp->ClearColorIiEXT) {
8820         void ** procp = (void **) &disp->ClearColorIiEXT;
8821         snprintf(symboln, sizeof(symboln), "%sClearColorIiEXT", symbol_prefix);
8822         *procp = dlsym(handle, symboln);
8823     }
8824
8825
8826     if(!disp->ClearColorIuiEXT) {
8827         void ** procp = (void **) &disp->ClearColorIuiEXT;
8828         snprintf(symboln, sizeof(symboln), "%sClearColorIuiEXT", symbol_prefix);
8829         *procp = dlsym(handle, symboln);
8830     }
8831
8832
8833     if(!disp->GetTexParameterIivEXT) {
8834         void ** procp = (void **) &disp->GetTexParameterIivEXT;
8835         snprintf(symboln, sizeof(symboln), "%sGetTexParameterIivEXT", symbol_prefix);
8836         *procp = dlsym(handle, symboln);
8837     }
8838
8839
8840     if(!disp->GetTexParameterIivEXT) {
8841         void ** procp = (void **) &disp->GetTexParameterIivEXT;
8842         snprintf(symboln, sizeof(symboln), "%sGetTexParameterIiv", symbol_prefix);
8843         *procp = dlsym(handle, symboln);
8844     }
8845
8846
8847     if(!disp->GetTexParameterIuivEXT) {
8848         void ** procp = (void **) &disp->GetTexParameterIuivEXT;
8849         snprintf(symboln, sizeof(symboln), "%sGetTexParameterIuivEXT", symbol_prefix);
8850         *procp = dlsym(handle, symboln);
8851     }
8852
8853
8854     if(!disp->GetTexParameterIuivEXT) {
8855         void ** procp = (void **) &disp->GetTexParameterIuivEXT;
8856         snprintf(symboln, sizeof(symboln), "%sGetTexParameterIuiv", symbol_prefix);
8857         *procp = dlsym(handle, symboln);
8858     }
8859
8860
8861     if(!disp->TexParameterIivEXT) {
8862         void ** procp = (void **) &disp->TexParameterIivEXT;
8863         snprintf(symboln, sizeof(symboln), "%sTexParameterIivEXT", symbol_prefix);
8864         *procp = dlsym(handle, symboln);
8865     }
8866
8867
8868     if(!disp->TexParameterIivEXT) {
8869         void ** procp = (void **) &disp->TexParameterIivEXT;
8870         snprintf(symboln, sizeof(symboln), "%sTexParameterIiv", symbol_prefix);
8871         *procp = dlsym(handle, symboln);
8872     }
8873
8874
8875     if(!disp->TexParameterIuivEXT) {
8876         void ** procp = (void **) &disp->TexParameterIuivEXT;
8877         snprintf(symboln, sizeof(symboln), "%sTexParameterIuivEXT", symbol_prefix);
8878         *procp = dlsym(handle, symboln);
8879     }
8880
8881
8882     if(!disp->TexParameterIuivEXT) {
8883         void ** procp = (void **) &disp->TexParameterIuivEXT;
8884         snprintf(symboln, sizeof(symboln), "%sTexParameterIuiv", symbol_prefix);
8885         *procp = dlsym(handle, symboln);
8886     }
8887
8888
8889     if(!disp->BeginConditionalRenderNV) {
8890         void ** procp = (void **) &disp->BeginConditionalRenderNV;
8891         snprintf(symboln, sizeof(symboln), "%sBeginConditionalRenderNV", symbol_prefix);
8892         *procp = dlsym(handle, symboln);
8893     }
8894
8895
8896     if(!disp->BeginConditionalRenderNV) {
8897         void ** procp = (void **) &disp->BeginConditionalRenderNV;
8898         snprintf(symboln, sizeof(symboln), "%sBeginConditionalRender", symbol_prefix);
8899         *procp = dlsym(handle, symboln);
8900     }
8901
8902
8903     if(!disp->EndConditionalRenderNV) {
8904         void ** procp = (void **) &disp->EndConditionalRenderNV;
8905         snprintf(symboln, sizeof(symboln), "%sEndConditionalRenderNV", symbol_prefix);
8906         *procp = dlsym(handle, symboln);
8907     }
8908
8909
8910     if(!disp->EndConditionalRenderNV) {
8911         void ** procp = (void **) &disp->EndConditionalRenderNV;
8912         snprintf(symboln, sizeof(symboln), "%sEndConditionalRender", symbol_prefix);
8913         *procp = dlsym(handle, symboln);
8914     }
8915
8916
8917     if(!disp->BeginTransformFeedbackEXT) {
8918         void ** procp = (void **) &disp->BeginTransformFeedbackEXT;
8919         snprintf(symboln, sizeof(symboln), "%sBeginTransformFeedbackEXT", symbol_prefix);
8920         *procp = dlsym(handle, symboln);
8921     }
8922
8923
8924     if(!disp->BeginTransformFeedbackEXT) {
8925         void ** procp = (void **) &disp->BeginTransformFeedbackEXT;
8926         snprintf(symboln, sizeof(symboln), "%sBeginTransformFeedback", symbol_prefix);
8927         *procp = dlsym(handle, symboln);
8928     }
8929
8930
8931     if(!disp->BindBufferBaseEXT) {
8932         void ** procp = (void **) &disp->BindBufferBaseEXT;
8933         snprintf(symboln, sizeof(symboln), "%sBindBufferBaseEXT", symbol_prefix);
8934         *procp = dlsym(handle, symboln);
8935     }
8936
8937
8938     if(!disp->BindBufferBaseEXT) {
8939         void ** procp = (void **) &disp->BindBufferBaseEXT;
8940         snprintf(symboln, sizeof(symboln), "%sBindBufferBase", symbol_prefix);
8941         *procp = dlsym(handle, symboln);
8942     }
8943
8944
8945     if(!disp->BindBufferOffsetEXT) {
8946         void ** procp = (void **) &disp->BindBufferOffsetEXT;
8947         snprintf(symboln, sizeof(symboln), "%sBindBufferOffsetEXT", symbol_prefix);
8948         *procp = dlsym(handle, symboln);
8949     }
8950
8951
8952     if(!disp->BindBufferRangeEXT) {
8953         void ** procp = (void **) &disp->BindBufferRangeEXT;
8954         snprintf(symboln, sizeof(symboln), "%sBindBufferRangeEXT", symbol_prefix);
8955         *procp = dlsym(handle, symboln);
8956     }
8957
8958
8959     if(!disp->BindBufferRangeEXT) {
8960         void ** procp = (void **) &disp->BindBufferRangeEXT;
8961         snprintf(symboln, sizeof(symboln), "%sBindBufferRange", symbol_prefix);
8962         *procp = dlsym(handle, symboln);
8963     }
8964
8965
8966     if(!disp->EndTransformFeedbackEXT) {
8967         void ** procp = (void **) &disp->EndTransformFeedbackEXT;
8968         snprintf(symboln, sizeof(symboln), "%sEndTransformFeedbackEXT", symbol_prefix);
8969         *procp = dlsym(handle, symboln);
8970     }
8971
8972
8973     if(!disp->EndTransformFeedbackEXT) {
8974         void ** procp = (void **) &disp->EndTransformFeedbackEXT;
8975         snprintf(symboln, sizeof(symboln), "%sEndTransformFeedback", symbol_prefix);
8976         *procp = dlsym(handle, symboln);
8977     }
8978
8979
8980     if(!disp->GetTransformFeedbackVaryingEXT) {
8981         void ** procp = (void **) &disp->GetTransformFeedbackVaryingEXT;
8982         snprintf(symboln, sizeof(symboln), "%sGetTransformFeedbackVaryingEXT", symbol_prefix);
8983         *procp = dlsym(handle, symboln);
8984     }
8985
8986
8987     if(!disp->GetTransformFeedbackVaryingEXT) {
8988         void ** procp = (void **) &disp->GetTransformFeedbackVaryingEXT;
8989         snprintf(symboln, sizeof(symboln), "%sGetTransformFeedbackVarying", symbol_prefix);
8990         *procp = dlsym(handle, symboln);
8991     }
8992
8993
8994     if(!disp->TransformFeedbackVaryingsEXT) {
8995         void ** procp = (void **) &disp->TransformFeedbackVaryingsEXT;
8996         snprintf(symboln, sizeof(symboln), "%sTransformFeedbackVaryingsEXT", symbol_prefix);
8997         *procp = dlsym(handle, symboln);
8998     }
8999
9000
9001     if(!disp->TransformFeedbackVaryingsEXT) {
9002         void ** procp = (void **) &disp->TransformFeedbackVaryingsEXT;
9003         snprintf(symboln, sizeof(symboln), "%sTransformFeedbackVaryings", symbol_prefix);
9004         *procp = dlsym(handle, symboln);
9005     }
9006
9007
9008     if(!disp->ProvokingVertexEXT) {
9009         void ** procp = (void **) &disp->ProvokingVertexEXT;
9010         snprintf(symboln, sizeof(symboln), "%sProvokingVertexEXT", symbol_prefix);
9011         *procp = dlsym(handle, symboln);
9012     }
9013
9014
9015     if(!disp->ProvokingVertexEXT) {
9016         void ** procp = (void **) &disp->ProvokingVertexEXT;
9017         snprintf(symboln, sizeof(symboln), "%sProvokingVertex", symbol_prefix);
9018         *procp = dlsym(handle, symboln);
9019     }
9020
9021
9022     if(!disp->GetTexParameterPointervAPPLE) {
9023         void ** procp = (void **) &disp->GetTexParameterPointervAPPLE;
9024         snprintf(symboln, sizeof(symboln), "%sGetTexParameterPointervAPPLE", symbol_prefix);
9025         *procp = dlsym(handle, symboln);
9026     }
9027
9028
9029     if(!disp->TextureRangeAPPLE) {
9030         void ** procp = (void **) &disp->TextureRangeAPPLE;
9031         snprintf(symboln, sizeof(symboln), "%sTextureRangeAPPLE", symbol_prefix);
9032         *procp = dlsym(handle, symboln);
9033     }
9034
9035
9036     if(!disp->GetObjectParameterivAPPLE) {
9037         void ** procp = (void **) &disp->GetObjectParameterivAPPLE;
9038         snprintf(symboln, sizeof(symboln), "%sGetObjectParameterivAPPLE", symbol_prefix);
9039         *procp = dlsym(handle, symboln);
9040     }
9041
9042
9043     if(!disp->ObjectPurgeableAPPLE) {
9044         void ** procp = (void **) &disp->ObjectPurgeableAPPLE;
9045         snprintf(symboln, sizeof(symboln), "%sObjectPurgeableAPPLE", symbol_prefix);
9046         *procp = dlsym(handle, symboln);
9047     }
9048
9049
9050     if(!disp->ObjectUnpurgeableAPPLE) {
9051         void ** procp = (void **) &disp->ObjectUnpurgeableAPPLE;
9052         snprintf(symboln, sizeof(symboln), "%sObjectUnpurgeableAPPLE", symbol_prefix);
9053         *procp = dlsym(handle, symboln);
9054     }
9055
9056
9057     if(!disp->ActiveProgramEXT) {
9058         void ** procp = (void **) &disp->ActiveProgramEXT;
9059         snprintf(symboln, sizeof(symboln), "%sActiveProgramEXT", symbol_prefix);
9060         *procp = dlsym(handle, symboln);
9061     }
9062
9063
9064     if(!disp->CreateShaderProgramEXT) {
9065         void ** procp = (void **) &disp->CreateShaderProgramEXT;
9066         snprintf(symboln, sizeof(symboln), "%sCreateShaderProgramEXT", symbol_prefix);
9067         *procp = dlsym(handle, symboln);
9068     }
9069
9070
9071     if(!disp->UseShaderProgramEXT) {
9072         void ** procp = (void **) &disp->UseShaderProgramEXT;
9073         snprintf(symboln, sizeof(symboln), "%sUseShaderProgramEXT", symbol_prefix);
9074         *procp = dlsym(handle, symboln);
9075     }
9076
9077
9078     if(!disp->TextureBarrierNV) {
9079         void ** procp = (void **) &disp->TextureBarrierNV;
9080         snprintf(symboln, sizeof(symboln), "%sTextureBarrierNV", symbol_prefix);
9081         *procp = dlsym(handle, symboln);
9082     }
9083
9084
9085     if(!disp->StencilFuncSeparateATI) {
9086         void ** procp = (void **) &disp->StencilFuncSeparateATI;
9087         snprintf(symboln, sizeof(symboln), "%sStencilFuncSeparateATI", symbol_prefix);
9088         *procp = dlsym(handle, symboln);
9089     }
9090
9091
9092     if(!disp->ProgramEnvParameters4fvEXT) {
9093         void ** procp = (void **) &disp->ProgramEnvParameters4fvEXT;
9094         snprintf(symboln, sizeof(symboln), "%sProgramEnvParameters4fvEXT", symbol_prefix);
9095         *procp = dlsym(handle, symboln);
9096     }
9097
9098
9099     if(!disp->ProgramLocalParameters4fvEXT) {
9100         void ** procp = (void **) &disp->ProgramLocalParameters4fvEXT;
9101         snprintf(symboln, sizeof(symboln), "%sProgramLocalParameters4fvEXT", symbol_prefix);
9102         *procp = dlsym(handle, symboln);
9103     }
9104
9105
9106     if(!disp->GetQueryObjecti64vEXT) {
9107         void ** procp = (void **) &disp->GetQueryObjecti64vEXT;
9108         snprintf(symboln, sizeof(symboln), "%sGetQueryObjecti64vEXT", symbol_prefix);
9109         *procp = dlsym(handle, symboln);
9110     }
9111
9112
9113     if(!disp->GetQueryObjectui64vEXT) {
9114         void ** procp = (void **) &disp->GetQueryObjectui64vEXT;
9115         snprintf(symboln, sizeof(symboln), "%sGetQueryObjectui64vEXT", symbol_prefix);
9116         *procp = dlsym(handle, symboln);
9117     }
9118
9119
9120     if(!disp->EGLImageTargetRenderbufferStorageOES) {
9121         void ** procp = (void **) &disp->EGLImageTargetRenderbufferStorageOES;
9122         snprintf(symboln, sizeof(symboln), "%sEGLImageTargetRenderbufferStorageOES", symbol_prefix);
9123         *procp = dlsym(handle, symboln);
9124     }
9125
9126
9127     if(!disp->EGLImageTargetTexture2DOES) {
9128         void ** procp = (void **) &disp->EGLImageTargetTexture2DOES;
9129         snprintf(symboln, sizeof(symboln), "%sEGLImageTargetTexture2DOES", symbol_prefix);
9130         *procp = dlsym(handle, symboln);
9131     }
9132
9133
9134     __glapi_gentable_set_remaining_noop(disp);
9135
9136     return disp;
9137 }
9138