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