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