1 /*
2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 *
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
29 */
30
31 #include "glxserver.h"
32 #include "glxext.h"
33 #include "g_disptab.h"
34 #include "unpack.h"
35 #include "compsize.h"
36
37 void
__glXDispSwap_CallList(GLbyte * pc)38 __glXDispSwap_CallList(GLbyte * pc)
39 {
40 __GLX_DECLARE_SWAP_VARIABLES;
41
42 __GLX_SWAP_INT(pc + 0);
43
44 }
45
46 void
__glXDispSwap_ListBase(GLbyte * pc)47 __glXDispSwap_ListBase(GLbyte * pc)
48 {
49 __GLX_DECLARE_SWAP_VARIABLES;
50
51 __GLX_SWAP_INT(pc + 0);
52
53 }
54
55 void
__glXDispSwap_Begin(GLbyte * pc)56 __glXDispSwap_Begin(GLbyte * pc)
57 {
58 __GLX_DECLARE_SWAP_VARIABLES;
59
60 __GLX_SWAP_INT(pc + 0);
61
62 }
63
64 void
__glXDispSwap_Color3bv(GLbyte * pc)65 __glXDispSwap_Color3bv(GLbyte * pc)
66 {
67 }
68
69 void
__glXDispSwap_Color3dv(GLbyte * pc)70 __glXDispSwap_Color3dv(GLbyte * pc)
71 {
72 __GLX_DECLARE_SWAP_VARIABLES;
73 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
74
75 #ifdef __GLX_ALIGN64
76 if ((unsigned long) (pc) & 7) {
77 __GLX_MEM_COPY(pc - 4, pc, 24);
78 pc -= 4;
79 }
80 #endif
81 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
82
83 }
84
85 void
__glXDispSwap_Color3fv(GLbyte * pc)86 __glXDispSwap_Color3fv(GLbyte * pc)
87 {
88 __GLX_DECLARE_SWAP_VARIABLES;
89 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
90
91 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
92 }
93
94 void
__glXDispSwap_Color3iv(GLbyte * pc)95 __glXDispSwap_Color3iv(GLbyte * pc)
96 {
97 __GLX_DECLARE_SWAP_VARIABLES;
98 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
99
100 __GLX_SWAP_INT_ARRAY(pc + 0, 3);
101
102 }
103
104 void
__glXDispSwap_Color3sv(GLbyte * pc)105 __glXDispSwap_Color3sv(GLbyte * pc)
106 {
107 __GLX_DECLARE_SWAP_VARIABLES;
108 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
109
110 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
111
112 }
113
114 void
__glXDispSwap_Color3ubv(GLbyte * pc)115 __glXDispSwap_Color3ubv(GLbyte * pc)
116 {
117 }
118
119 void
__glXDispSwap_Color3uiv(GLbyte * pc)120 __glXDispSwap_Color3uiv(GLbyte * pc)
121 {
122 __GLX_DECLARE_SWAP_VARIABLES;
123 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
124
125 __GLX_SWAP_INT_ARRAY(pc + 0, 3);
126 }
127
128 void
__glXDispSwap_Color3usv(GLbyte * pc)129 __glXDispSwap_Color3usv(GLbyte * pc)
130 {
131 __GLX_DECLARE_SWAP_VARIABLES;
132 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
133
134 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
135 }
136
137 void
__glXDispSwap_Color4bv(GLbyte * pc)138 __glXDispSwap_Color4bv(GLbyte * pc)
139 {
140 }
141
142 void
__glXDispSwap_Color4dv(GLbyte * pc)143 __glXDispSwap_Color4dv(GLbyte * pc)
144 {
145 __GLX_DECLARE_SWAP_VARIABLES;
146 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
147
148 #ifdef __GLX_ALIGN64
149 if ((unsigned long) (pc) & 7) {
150 __GLX_MEM_COPY(pc - 4, pc, 32);
151 pc -= 4;
152 }
153 #endif
154 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
155 }
156
157 void
__glXDispSwap_Color4fv(GLbyte * pc)158 __glXDispSwap_Color4fv(GLbyte * pc)
159 {
160 __GLX_DECLARE_SWAP_VARIABLES;
161 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
162
163 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
164
165 }
166
167 void
__glXDispSwap_Color4iv(GLbyte * pc)168 __glXDispSwap_Color4iv(GLbyte * pc)
169 {
170 __GLX_DECLARE_SWAP_VARIABLES;
171 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
172
173 __GLX_SWAP_INT_ARRAY(pc + 0, 4);
174
175 }
176
177 void
__glXDispSwap_Color4sv(GLbyte * pc)178 __glXDispSwap_Color4sv(GLbyte * pc)
179 {
180 __GLX_DECLARE_SWAP_VARIABLES;
181 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
182
183 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
184
185 }
186
187 void
__glXDispSwap_Color4ubv(GLbyte * pc)188 __glXDispSwap_Color4ubv(GLbyte * pc)
189 {
190
191 }
192
193 void
__glXDispSwap_Color4uiv(GLbyte * pc)194 __glXDispSwap_Color4uiv(GLbyte * pc)
195 {
196 __GLX_DECLARE_SWAP_VARIABLES;
197 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
198
199 __GLX_SWAP_INT_ARRAY(pc + 0, 4);
200
201 }
202
203 void
__glXDispSwap_Color4usv(GLbyte * pc)204 __glXDispSwap_Color4usv(GLbyte * pc)
205 {
206 __GLX_DECLARE_SWAP_VARIABLES;
207 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
208
209 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
210
211 }
212
213 void
__glXDispSwap_EdgeFlagv(GLbyte * pc)214 __glXDispSwap_EdgeFlagv(GLbyte * pc)
215 {
216 }
217
218 void
__glXDispSwap_End(GLbyte * pc)219 __glXDispSwap_End(GLbyte * pc)
220 {
221 }
222
223 void
__glXDispSwap_Indexdv(GLbyte * pc)224 __glXDispSwap_Indexdv(GLbyte * pc)
225 {
226 __GLX_DECLARE_SWAP_VARIABLES;
227 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
228
229 #ifdef __GLX_ALIGN64
230 if ((unsigned long) (pc) & 7) {
231 __GLX_MEM_COPY(pc - 4, pc, 8);
232 pc -= 4;
233 }
234 #endif
235 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
236
237 }
238
239 void
__glXDispSwap_Indexfv(GLbyte * pc)240 __glXDispSwap_Indexfv(GLbyte * pc)
241 {
242 __GLX_DECLARE_SWAP_VARIABLES;
243 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
244
245 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
246
247 }
248
249 void
__glXDispSwap_Indexiv(GLbyte * pc)250 __glXDispSwap_Indexiv(GLbyte * pc)
251 {
252 __GLX_DECLARE_SWAP_VARIABLES;
253 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
254
255 __GLX_SWAP_INT_ARRAY(pc + 0, 1);
256
257 }
258
259 void
__glXDispSwap_Indexsv(GLbyte * pc)260 __glXDispSwap_Indexsv(GLbyte * pc)
261 {
262 __GLX_DECLARE_SWAP_VARIABLES;
263 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
264
265 __GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
266
267 }
268
269 void
__glXDispSwap_Normal3bv(GLbyte * pc)270 __glXDispSwap_Normal3bv(GLbyte * pc)
271 {
272 }
273
274 void
__glXDispSwap_Normal3dv(GLbyte * pc)275 __glXDispSwap_Normal3dv(GLbyte * pc)
276 {
277 __GLX_DECLARE_SWAP_VARIABLES;
278 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
279
280 #ifdef __GLX_ALIGN64
281 if ((unsigned long) (pc) & 7) {
282 __GLX_MEM_COPY(pc - 4, pc, 24);
283 pc -= 4;
284 }
285 #endif
286 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
287
288 }
289
290 void
__glXDispSwap_Normal3fv(GLbyte * pc)291 __glXDispSwap_Normal3fv(GLbyte * pc)
292 {
293 __GLX_DECLARE_SWAP_VARIABLES;
294 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
295
296 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
297
298 }
299
300 void
__glXDispSwap_Normal3iv(GLbyte * pc)301 __glXDispSwap_Normal3iv(GLbyte * pc)
302 {
303 __GLX_DECLARE_SWAP_VARIABLES;
304 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
305
306 __GLX_SWAP_INT_ARRAY(pc + 0, 3);
307
308 }
309
310 void
__glXDispSwap_Normal3sv(GLbyte * pc)311 __glXDispSwap_Normal3sv(GLbyte * pc)
312 {
313 __GLX_DECLARE_SWAP_VARIABLES;
314 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
315
316 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
317
318 }
319
320 void
__glXDispSwap_RasterPos2dv(GLbyte * pc)321 __glXDispSwap_RasterPos2dv(GLbyte * pc)
322 {
323 __GLX_DECLARE_SWAP_VARIABLES;
324 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
325
326 #ifdef __GLX_ALIGN64
327 if ((unsigned long) (pc) & 7) {
328 __GLX_MEM_COPY(pc - 4, pc, 16);
329 pc -= 4;
330 }
331 #endif
332 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
333
334 }
335
336 void
__glXDispSwap_RasterPos2fv(GLbyte * pc)337 __glXDispSwap_RasterPos2fv(GLbyte * pc)
338 {
339 __GLX_DECLARE_SWAP_VARIABLES;
340 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
341
342 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
343
344 }
345
346 void
__glXDispSwap_RasterPos2iv(GLbyte * pc)347 __glXDispSwap_RasterPos2iv(GLbyte * pc)
348 {
349 __GLX_DECLARE_SWAP_VARIABLES;
350 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
351
352 __GLX_SWAP_INT_ARRAY(pc + 0, 2);
353
354 }
355
356 void
__glXDispSwap_RasterPos2sv(GLbyte * pc)357 __glXDispSwap_RasterPos2sv(GLbyte * pc)
358 {
359 __GLX_DECLARE_SWAP_VARIABLES;
360 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
361
362 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
363
364 }
365
366 void
__glXDispSwap_RasterPos3dv(GLbyte * pc)367 __glXDispSwap_RasterPos3dv(GLbyte * pc)
368 {
369 __GLX_DECLARE_SWAP_VARIABLES;
370 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
371
372 #ifdef __GLX_ALIGN64
373 if ((unsigned long) (pc) & 7) {
374 __GLX_MEM_COPY(pc - 4, pc, 24);
375 pc -= 4;
376 }
377 #endif
378 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
379
380 }
381
382 void
__glXDispSwap_RasterPos3fv(GLbyte * pc)383 __glXDispSwap_RasterPos3fv(GLbyte * pc)
384 {
385 __GLX_DECLARE_SWAP_VARIABLES;
386 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
387
388 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
389
390 }
391
392 void
__glXDispSwap_RasterPos3iv(GLbyte * pc)393 __glXDispSwap_RasterPos3iv(GLbyte * pc)
394 {
395 __GLX_DECLARE_SWAP_VARIABLES;
396 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
397
398 __GLX_SWAP_INT_ARRAY(pc + 0, 3);
399
400 }
401
402 void
__glXDispSwap_RasterPos3sv(GLbyte * pc)403 __glXDispSwap_RasterPos3sv(GLbyte * pc)
404 {
405 __GLX_DECLARE_SWAP_VARIABLES;
406 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
407
408 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
409
410 }
411
412 void
__glXDispSwap_RasterPos4dv(GLbyte * pc)413 __glXDispSwap_RasterPos4dv(GLbyte * pc)
414 {
415 __GLX_DECLARE_SWAP_VARIABLES;
416 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
417
418 #ifdef __GLX_ALIGN64
419 if ((unsigned long) (pc) & 7) {
420 __GLX_MEM_COPY(pc - 4, pc, 32);
421 pc -= 4;
422 }
423 #endif
424 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
425
426 }
427
428 void
__glXDispSwap_RasterPos4fv(GLbyte * pc)429 __glXDispSwap_RasterPos4fv(GLbyte * pc)
430 {
431 __GLX_DECLARE_SWAP_VARIABLES;
432 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
433
434 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
435
436 }
437
438 void
__glXDispSwap_RasterPos4iv(GLbyte * pc)439 __glXDispSwap_RasterPos4iv(GLbyte * pc)
440 {
441 __GLX_DECLARE_SWAP_VARIABLES;
442 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
443
444 __GLX_SWAP_INT_ARRAY(pc + 0, 4);
445
446 }
447
448 void
__glXDispSwap_RasterPos4sv(GLbyte * pc)449 __glXDispSwap_RasterPos4sv(GLbyte * pc)
450 {
451 __GLX_DECLARE_SWAP_VARIABLES;
452 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
453
454 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
455
456 }
457
458 void
__glXDispSwap_Rectdv(GLbyte * pc)459 __glXDispSwap_Rectdv(GLbyte * pc)
460 {
461 __GLX_DECLARE_SWAP_VARIABLES;
462 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
463
464 #ifdef __GLX_ALIGN64
465 if ((unsigned long) (pc) & 7) {
466 __GLX_MEM_COPY(pc - 4, pc, 32);
467 pc -= 4;
468 }
469 #endif
470 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
471 __GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2);
472
473 }
474
475 void
__glXDispSwap_Rectfv(GLbyte * pc)476 __glXDispSwap_Rectfv(GLbyte * pc)
477 {
478 __GLX_DECLARE_SWAP_VARIABLES;
479 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
480
481 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
482 __GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);
483
484 }
485
486 void
__glXDispSwap_Rectiv(GLbyte * pc)487 __glXDispSwap_Rectiv(GLbyte * pc)
488 {
489 __GLX_DECLARE_SWAP_VARIABLES;
490 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
491
492 __GLX_SWAP_INT_ARRAY(pc + 0, 2);
493 __GLX_SWAP_INT_ARRAY(pc + 8, 2);
494
495 }
496
497 void
__glXDispSwap_Rectsv(GLbyte * pc)498 __glXDispSwap_Rectsv(GLbyte * pc)
499 {
500 __GLX_DECLARE_SWAP_VARIABLES;
501 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
502
503 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
504 __GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
505
506 }
507
508 void
__glXDispSwap_TexCoord1dv(GLbyte * pc)509 __glXDispSwap_TexCoord1dv(GLbyte * pc)
510 {
511 __GLX_DECLARE_SWAP_VARIABLES;
512 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
513
514 #ifdef __GLX_ALIGN64
515 if ((unsigned long) (pc) & 7) {
516 __GLX_MEM_COPY(pc - 4, pc, 8);
517 pc -= 4;
518 }
519 #endif
520 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
521
522 }
523
524 void
__glXDispSwap_TexCoord1fv(GLbyte * pc)525 __glXDispSwap_TexCoord1fv(GLbyte * pc)
526 {
527 __GLX_DECLARE_SWAP_VARIABLES;
528 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
529
530 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
531
532 }
533
534 void
__glXDispSwap_TexCoord1iv(GLbyte * pc)535 __glXDispSwap_TexCoord1iv(GLbyte * pc)
536 {
537 __GLX_DECLARE_SWAP_VARIABLES;
538 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
539
540 __GLX_SWAP_INT_ARRAY(pc + 0, 1);
541
542 }
543
544 void
__glXDispSwap_TexCoord1sv(GLbyte * pc)545 __glXDispSwap_TexCoord1sv(GLbyte * pc)
546 {
547 __GLX_DECLARE_SWAP_VARIABLES;
548 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
549
550 __GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
551
552 }
553
554 void
__glXDispSwap_TexCoord2dv(GLbyte * pc)555 __glXDispSwap_TexCoord2dv(GLbyte * pc)
556 {
557 __GLX_DECLARE_SWAP_VARIABLES;
558 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
559
560 #ifdef __GLX_ALIGN64
561 if ((unsigned long) (pc) & 7) {
562 __GLX_MEM_COPY(pc - 4, pc, 16);
563 pc -= 4;
564 }
565 #endif
566 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
567
568 }
569
570 void
__glXDispSwap_TexCoord2fv(GLbyte * pc)571 __glXDispSwap_TexCoord2fv(GLbyte * pc)
572 {
573 __GLX_DECLARE_SWAP_VARIABLES;
574 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
575
576 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
577
578 }
579
580 void
__glXDispSwap_TexCoord2iv(GLbyte * pc)581 __glXDispSwap_TexCoord2iv(GLbyte * pc)
582 {
583 __GLX_DECLARE_SWAP_VARIABLES;
584 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
585
586 __GLX_SWAP_INT_ARRAY(pc + 0, 2);
587
588 }
589
590 void
__glXDispSwap_TexCoord2sv(GLbyte * pc)591 __glXDispSwap_TexCoord2sv(GLbyte * pc)
592 {
593 __GLX_DECLARE_SWAP_VARIABLES;
594 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
595
596 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
597
598 }
599
600 void
__glXDispSwap_TexCoord3dv(GLbyte * pc)601 __glXDispSwap_TexCoord3dv(GLbyte * pc)
602 {
603 __GLX_DECLARE_SWAP_VARIABLES;
604 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
605
606 #ifdef __GLX_ALIGN64
607 if ((unsigned long) (pc) & 7) {
608 __GLX_MEM_COPY(pc - 4, pc, 24);
609 pc -= 4;
610 }
611 #endif
612 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
613
614 }
615
616 void
__glXDispSwap_TexCoord3fv(GLbyte * pc)617 __glXDispSwap_TexCoord3fv(GLbyte * pc)
618 {
619 __GLX_DECLARE_SWAP_VARIABLES;
620 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
621
622 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
623
624 }
625
626 void
__glXDispSwap_TexCoord3iv(GLbyte * pc)627 __glXDispSwap_TexCoord3iv(GLbyte * pc)
628 {
629 __GLX_DECLARE_SWAP_VARIABLES;
630 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
631
632 __GLX_SWAP_INT_ARRAY(pc + 0, 3);
633
634 }
635
636 void
__glXDispSwap_TexCoord3sv(GLbyte * pc)637 __glXDispSwap_TexCoord3sv(GLbyte * pc)
638 {
639 __GLX_DECLARE_SWAP_VARIABLES;
640 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
641
642 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
643
644 }
645
646 void
__glXDispSwap_TexCoord4dv(GLbyte * pc)647 __glXDispSwap_TexCoord4dv(GLbyte * pc)
648 {
649 __GLX_DECLARE_SWAP_VARIABLES;
650 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
651
652 #ifdef __GLX_ALIGN64
653 if ((unsigned long) (pc) & 7) {
654 __GLX_MEM_COPY(pc - 4, pc, 32);
655 pc -= 4;
656 }
657 #endif
658 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
659
660 }
661
662 void
__glXDispSwap_TexCoord4fv(GLbyte * pc)663 __glXDispSwap_TexCoord4fv(GLbyte * pc)
664 {
665 __GLX_DECLARE_SWAP_VARIABLES;
666 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
667
668 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
669
670 }
671
672 void
__glXDispSwap_TexCoord4iv(GLbyte * pc)673 __glXDispSwap_TexCoord4iv(GLbyte * pc)
674 {
675 __GLX_DECLARE_SWAP_VARIABLES;
676 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
677
678 __GLX_SWAP_INT_ARRAY(pc + 0, 4);
679
680 }
681
682 void
__glXDispSwap_TexCoord4sv(GLbyte * pc)683 __glXDispSwap_TexCoord4sv(GLbyte * pc)
684 {
685 __GLX_DECLARE_SWAP_VARIABLES;
686 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
687
688 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
689
690 }
691
692 void
__glXDispSwap_Vertex2dv(GLbyte * pc)693 __glXDispSwap_Vertex2dv(GLbyte * pc)
694 {
695 __GLX_DECLARE_SWAP_VARIABLES;
696 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
697
698 #ifdef __GLX_ALIGN64
699 if ((unsigned long) (pc) & 7) {
700 __GLX_MEM_COPY(pc - 4, pc, 16);
701 pc -= 4;
702 }
703 #endif
704 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
705
706 }
707
708 void
__glXDispSwap_Vertex2fv(GLbyte * pc)709 __glXDispSwap_Vertex2fv(GLbyte * pc)
710 {
711 __GLX_DECLARE_SWAP_VARIABLES;
712 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
713
714 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
715
716 }
717
718 void
__glXDispSwap_Vertex2iv(GLbyte * pc)719 __glXDispSwap_Vertex2iv(GLbyte * pc)
720 {
721 __GLX_DECLARE_SWAP_VARIABLES;
722 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
723
724 __GLX_SWAP_INT_ARRAY(pc + 0, 2);
725
726 }
727
728 void
__glXDispSwap_Vertex2sv(GLbyte * pc)729 __glXDispSwap_Vertex2sv(GLbyte * pc)
730 {
731 __GLX_DECLARE_SWAP_VARIABLES;
732 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
733
734 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
735
736 }
737
738 void
__glXDispSwap_Vertex3dv(GLbyte * pc)739 __glXDispSwap_Vertex3dv(GLbyte * pc)
740 {
741 __GLX_DECLARE_SWAP_VARIABLES;
742 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
743
744 #ifdef __GLX_ALIGN64
745 if ((unsigned long) (pc) & 7) {
746 __GLX_MEM_COPY(pc - 4, pc, 24);
747 pc -= 4;
748 }
749 #endif
750 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
751
752 }
753
754 void
__glXDispSwap_Vertex3fv(GLbyte * pc)755 __glXDispSwap_Vertex3fv(GLbyte * pc)
756 {
757 __GLX_DECLARE_SWAP_VARIABLES;
758 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
759
760 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
761
762 }
763
764 void
__glXDispSwap_Vertex3iv(GLbyte * pc)765 __glXDispSwap_Vertex3iv(GLbyte * pc)
766 {
767 __GLX_DECLARE_SWAP_VARIABLES;
768 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
769
770 __GLX_SWAP_INT_ARRAY(pc + 0, 3);
771
772 }
773
774 void
__glXDispSwap_Vertex3sv(GLbyte * pc)775 __glXDispSwap_Vertex3sv(GLbyte * pc)
776 {
777 __GLX_DECLARE_SWAP_VARIABLES;
778 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
779
780 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
781
782 }
783
784 void
__glXDispSwap_Vertex4dv(GLbyte * pc)785 __glXDispSwap_Vertex4dv(GLbyte * pc)
786 {
787 __GLX_DECLARE_SWAP_VARIABLES;
788 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
789
790 #ifdef __GLX_ALIGN64
791 if ((unsigned long) (pc) & 7) {
792 __GLX_MEM_COPY(pc - 4, pc, 32);
793 pc -= 4;
794 }
795 #endif
796 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
797
798 }
799
800 void
__glXDispSwap_Vertex4fv(GLbyte * pc)801 __glXDispSwap_Vertex4fv(GLbyte * pc)
802 {
803 __GLX_DECLARE_SWAP_VARIABLES;
804 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
805
806 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
807
808 }
809
810 void
__glXDispSwap_Vertex4iv(GLbyte * pc)811 __glXDispSwap_Vertex4iv(GLbyte * pc)
812 {
813 __GLX_DECLARE_SWAP_VARIABLES;
814 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
815
816 __GLX_SWAP_INT_ARRAY(pc + 0, 4);
817
818 }
819
820 void
__glXDispSwap_Vertex4sv(GLbyte * pc)821 __glXDispSwap_Vertex4sv(GLbyte * pc)
822 {
823 __GLX_DECLARE_SWAP_VARIABLES;
824 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
825
826 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
827
828 }
829
830 void
__glXDispSwap_ClipPlane(GLbyte * pc)831 __glXDispSwap_ClipPlane(GLbyte * pc)
832 {
833 __GLX_DECLARE_SWAP_VARIABLES;
834 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
835
836 #ifdef __GLX_ALIGN64
837 if ((unsigned long) (pc) & 7) {
838 __GLX_MEM_COPY(pc - 4, pc, 36);
839 pc -= 4;
840 }
841 #endif
842 __GLX_SWAP_INT(pc + 32);
843 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
844
845 }
846
847 void
__glXDispSwap_ColorMaterial(GLbyte * pc)848 __glXDispSwap_ColorMaterial(GLbyte * pc)
849 {
850 __GLX_DECLARE_SWAP_VARIABLES;
851
852 __GLX_SWAP_INT(pc + 0);
853 __GLX_SWAP_INT(pc + 4);
854
855 }
856
857 void
__glXDispSwap_CullFace(GLbyte * pc)858 __glXDispSwap_CullFace(GLbyte * pc)
859 {
860 __GLX_DECLARE_SWAP_VARIABLES;
861
862 __GLX_SWAP_INT(pc + 0);
863
864 }
865
866 void
__glXDispSwap_Fogf(GLbyte * pc)867 __glXDispSwap_Fogf(GLbyte * pc)
868 {
869 __GLX_DECLARE_SWAP_VARIABLES;
870
871 __GLX_SWAP_INT(pc + 0);
872 __GLX_SWAP_FLOAT(pc + 4);
873
874 }
875
876 void
__glXDispSwap_Fogfv(GLbyte * pc)877 __glXDispSwap_Fogfv(GLbyte * pc)
878 {
879 GLenum pname;
880 GLint compsize;
881
882 __GLX_DECLARE_SWAP_VARIABLES;
883 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
884
885 __GLX_SWAP_INT(pc + 0);
886 pname = *(GLenum *) (pc + 0);
887 compsize = __glFogfv_size(pname);
888 if (compsize < 0)
889 compsize = 0;
890 __GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
891
892 }
893
894 void
__glXDispSwap_Fogi(GLbyte * pc)895 __glXDispSwap_Fogi(GLbyte * pc)
896 {
897 __GLX_DECLARE_SWAP_VARIABLES;
898
899 __GLX_SWAP_INT(pc + 0);
900 __GLX_SWAP_INT(pc + 4);
901
902 }
903
904 void
__glXDispSwap_Fogiv(GLbyte * pc)905 __glXDispSwap_Fogiv(GLbyte * pc)
906 {
907 GLenum pname;
908 GLint compsize;
909
910 __GLX_DECLARE_SWAP_VARIABLES;
911 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
912
913 __GLX_SWAP_INT(pc + 0);
914 pname = *(GLenum *) (pc + 0);
915 compsize = __glFogiv_size(pname);
916 if (compsize < 0)
917 compsize = 0;
918 __GLX_SWAP_INT_ARRAY(pc + 4, compsize);
919
920 }
921
922 void
__glXDispSwap_FrontFace(GLbyte * pc)923 __glXDispSwap_FrontFace(GLbyte * pc)
924 {
925 __GLX_DECLARE_SWAP_VARIABLES;
926
927 __GLX_SWAP_INT(pc + 0);
928
929 }
930
931 void
__glXDispSwap_Hint(GLbyte * pc)932 __glXDispSwap_Hint(GLbyte * pc)
933 {
934 __GLX_DECLARE_SWAP_VARIABLES;
935
936 __GLX_SWAP_INT(pc + 0);
937 __GLX_SWAP_INT(pc + 4);
938
939 }
940
941 void
__glXDispSwap_Lightf(GLbyte * pc)942 __glXDispSwap_Lightf(GLbyte * pc)
943 {
944 __GLX_DECLARE_SWAP_VARIABLES;
945
946 __GLX_SWAP_INT(pc + 0);
947 __GLX_SWAP_INT(pc + 4);
948 __GLX_SWAP_FLOAT(pc + 8);
949
950 }
951
952 void
__glXDispSwap_Lightfv(GLbyte * pc)953 __glXDispSwap_Lightfv(GLbyte * pc)
954 {
955 GLenum pname;
956 GLint compsize;
957
958 __GLX_DECLARE_SWAP_VARIABLES;
959 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
960
961 __GLX_SWAP_INT(pc + 4);
962 pname = *(GLenum *) (pc + 4);
963 compsize = __glLightfv_size(pname);
964 if (compsize < 0)
965 compsize = 0;
966 __GLX_SWAP_INT(pc + 0);
967 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
968
969 }
970
971 void
__glXDispSwap_Lighti(GLbyte * pc)972 __glXDispSwap_Lighti(GLbyte * pc)
973 {
974 __GLX_DECLARE_SWAP_VARIABLES;
975
976 __GLX_SWAP_INT(pc + 0);
977 __GLX_SWAP_INT(pc + 4);
978 __GLX_SWAP_INT(pc + 8);
979
980 }
981
982 void
__glXDispSwap_Lightiv(GLbyte * pc)983 __glXDispSwap_Lightiv(GLbyte * pc)
984 {
985 GLenum pname;
986 GLint compsize;
987
988 __GLX_DECLARE_SWAP_VARIABLES;
989 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
990
991 __GLX_SWAP_INT(pc + 4);
992 pname = *(GLenum *) (pc + 4);
993 compsize = __glLightiv_size(pname);
994 if (compsize < 0)
995 compsize = 0;
996 __GLX_SWAP_INT(pc + 0);
997 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
998
999 }
1000
1001 void
__glXDispSwap_LightModelf(GLbyte * pc)1002 __glXDispSwap_LightModelf(GLbyte * pc)
1003 {
1004 __GLX_DECLARE_SWAP_VARIABLES;
1005
1006 __GLX_SWAP_INT(pc + 0);
1007 __GLX_SWAP_FLOAT(pc + 4);
1008
1009 }
1010
1011 void
__glXDispSwap_LightModelfv(GLbyte * pc)1012 __glXDispSwap_LightModelfv(GLbyte * pc)
1013 {
1014 GLenum pname;
1015 GLint compsize;
1016
1017 __GLX_DECLARE_SWAP_VARIABLES;
1018 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1019
1020 __GLX_SWAP_INT(pc + 0);
1021 pname = *(GLenum *) (pc + 0);
1022 compsize = __glLightModelfv_size(pname);
1023 if (compsize < 0)
1024 compsize = 0;
1025 __GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
1026
1027 }
1028
1029 void
__glXDispSwap_LightModeli(GLbyte * pc)1030 __glXDispSwap_LightModeli(GLbyte * pc)
1031 {
1032 __GLX_DECLARE_SWAP_VARIABLES;
1033
1034 __GLX_SWAP_INT(pc + 0);
1035 __GLX_SWAP_INT(pc + 4);
1036
1037 }
1038
1039 void
__glXDispSwap_LightModeliv(GLbyte * pc)1040 __glXDispSwap_LightModeliv(GLbyte * pc)
1041 {
1042 GLenum pname;
1043 GLint compsize;
1044
1045 __GLX_DECLARE_SWAP_VARIABLES;
1046 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1047
1048 __GLX_SWAP_INT(pc + 0);
1049 pname = *(GLenum *) (pc + 0);
1050 compsize = __glLightModeliv_size(pname);
1051 if (compsize < 0)
1052 compsize = 0;
1053 __GLX_SWAP_INT_ARRAY(pc + 4, compsize);
1054
1055 }
1056
1057 void
__glXDispSwap_LineStipple(GLbyte * pc)1058 __glXDispSwap_LineStipple(GLbyte * pc)
1059 {
1060 __GLX_DECLARE_SWAP_VARIABLES;
1061
1062 __GLX_SWAP_INT(pc + 0);
1063 __GLX_SWAP_SHORT(pc + 4);
1064
1065 }
1066
1067 void
__glXDispSwap_LineWidth(GLbyte * pc)1068 __glXDispSwap_LineWidth(GLbyte * pc)
1069 {
1070 __GLX_DECLARE_SWAP_VARIABLES;
1071
1072 __GLX_SWAP_FLOAT(pc + 0);
1073
1074 }
1075
1076 void
__glXDispSwap_Materialf(GLbyte * pc)1077 __glXDispSwap_Materialf(GLbyte * pc)
1078 {
1079 __GLX_DECLARE_SWAP_VARIABLES;
1080
1081 __GLX_SWAP_INT(pc + 0);
1082 __GLX_SWAP_INT(pc + 4);
1083 __GLX_SWAP_FLOAT(pc + 8);
1084
1085 }
1086
1087 void
__glXDispSwap_Materialfv(GLbyte * pc)1088 __glXDispSwap_Materialfv(GLbyte * pc)
1089 {
1090 GLenum pname;
1091 GLint compsize;
1092
1093 __GLX_DECLARE_SWAP_VARIABLES;
1094 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1095
1096 __GLX_SWAP_INT(pc + 4);
1097 pname = *(GLenum *) (pc + 4);
1098 compsize = __glMaterialfv_size(pname);
1099 if (compsize < 0)
1100 compsize = 0;
1101 __GLX_SWAP_INT(pc + 0);
1102 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1103
1104 }
1105
1106 void
__glXDispSwap_Materiali(GLbyte * pc)1107 __glXDispSwap_Materiali(GLbyte * pc)
1108 {
1109 __GLX_DECLARE_SWAP_VARIABLES;
1110
1111 __GLX_SWAP_INT(pc + 0);
1112 __GLX_SWAP_INT(pc + 4);
1113 __GLX_SWAP_INT(pc + 8);
1114
1115 }
1116
1117 void
__glXDispSwap_Materialiv(GLbyte * pc)1118 __glXDispSwap_Materialiv(GLbyte * pc)
1119 {
1120 GLenum pname;
1121 GLint compsize;
1122
1123 __GLX_DECLARE_SWAP_VARIABLES;
1124 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1125
1126 __GLX_SWAP_INT(pc + 4);
1127 pname = *(GLenum *) (pc + 4);
1128 compsize = __glMaterialiv_size(pname);
1129 if (compsize < 0)
1130 compsize = 0;
1131 __GLX_SWAP_INT(pc + 0);
1132 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1133
1134 }
1135
1136 void
__glXDispSwap_PointSize(GLbyte * pc)1137 __glXDispSwap_PointSize(GLbyte * pc)
1138 {
1139 __GLX_DECLARE_SWAP_VARIABLES;
1140
1141 __GLX_SWAP_FLOAT(pc + 0);
1142
1143 }
1144
1145 void
__glXDispSwap_PolygonMode(GLbyte * pc)1146 __glXDispSwap_PolygonMode(GLbyte * pc)
1147 {
1148 __GLX_DECLARE_SWAP_VARIABLES;
1149
1150 __GLX_SWAP_INT(pc + 0);
1151 __GLX_SWAP_INT(pc + 4);
1152
1153 }
1154
1155 void
__glXDispSwap_Scissor(GLbyte * pc)1156 __glXDispSwap_Scissor(GLbyte * pc)
1157 {
1158 __GLX_DECLARE_SWAP_VARIABLES;
1159
1160 __GLX_SWAP_INT(pc + 0);
1161 __GLX_SWAP_INT(pc + 4);
1162 __GLX_SWAP_INT(pc + 8);
1163 __GLX_SWAP_INT(pc + 12);
1164
1165 }
1166
1167 void
__glXDispSwap_ShadeModel(GLbyte * pc)1168 __glXDispSwap_ShadeModel(GLbyte * pc)
1169 {
1170 __GLX_DECLARE_SWAP_VARIABLES;
1171
1172 __GLX_SWAP_INT(pc + 0);
1173
1174 }
1175
1176 void
__glXDispSwap_TexParameterf(GLbyte * pc)1177 __glXDispSwap_TexParameterf(GLbyte * pc)
1178 {
1179 __GLX_DECLARE_SWAP_VARIABLES;
1180
1181 __GLX_SWAP_INT(pc + 0);
1182 __GLX_SWAP_INT(pc + 4);
1183 __GLX_SWAP_FLOAT(pc + 8);
1184
1185 }
1186
1187 void
__glXDispSwap_TexParameterfv(GLbyte * pc)1188 __glXDispSwap_TexParameterfv(GLbyte * pc)
1189 {
1190 GLenum pname;
1191 GLint compsize;
1192
1193 __GLX_DECLARE_SWAP_VARIABLES;
1194 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1195
1196 __GLX_SWAP_INT(pc + 4);
1197 pname = *(GLenum *) (pc + 4);
1198 compsize = __glTexParameterfv_size(pname);
1199 if (compsize < 0)
1200 compsize = 0;
1201 __GLX_SWAP_INT(pc + 0);
1202 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1203
1204 }
1205
1206 void
__glXDispSwap_TexParameteri(GLbyte * pc)1207 __glXDispSwap_TexParameteri(GLbyte * pc)
1208 {
1209 __GLX_DECLARE_SWAP_VARIABLES;
1210
1211 __GLX_SWAP_INT(pc + 0);
1212 __GLX_SWAP_INT(pc + 4);
1213 __GLX_SWAP_INT(pc + 8);
1214
1215 }
1216
1217 void
__glXDispSwap_TexParameteriv(GLbyte * pc)1218 __glXDispSwap_TexParameteriv(GLbyte * pc)
1219 {
1220 GLenum pname;
1221 GLint compsize;
1222
1223 __GLX_DECLARE_SWAP_VARIABLES;
1224 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1225
1226 __GLX_SWAP_INT(pc + 4);
1227 pname = *(GLenum *) (pc + 4);
1228 compsize = __glTexParameteriv_size(pname);
1229 if (compsize < 0)
1230 compsize = 0;
1231 __GLX_SWAP_INT(pc + 0);
1232 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1233
1234 }
1235
1236 void
__glXDispSwap_TexEnvf(GLbyte * pc)1237 __glXDispSwap_TexEnvf(GLbyte * pc)
1238 {
1239 __GLX_DECLARE_SWAP_VARIABLES;
1240
1241 __GLX_SWAP_INT(pc + 0);
1242 __GLX_SWAP_INT(pc + 4);
1243 __GLX_SWAP_FLOAT(pc + 8);
1244
1245 }
1246
1247 void
__glXDispSwap_TexEnvfv(GLbyte * pc)1248 __glXDispSwap_TexEnvfv(GLbyte * pc)
1249 {
1250 GLenum pname;
1251 GLint compsize;
1252
1253 __GLX_DECLARE_SWAP_VARIABLES;
1254 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1255
1256 __GLX_SWAP_INT(pc + 4);
1257 pname = *(GLenum *) (pc + 4);
1258 compsize = __glTexEnvfv_size(pname);
1259 if (compsize < 0)
1260 compsize = 0;
1261 __GLX_SWAP_INT(pc + 0);
1262 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1263
1264 }
1265
1266 void
__glXDispSwap_TexEnvi(GLbyte * pc)1267 __glXDispSwap_TexEnvi(GLbyte * pc)
1268 {
1269 __GLX_DECLARE_SWAP_VARIABLES;
1270
1271 __GLX_SWAP_INT(pc + 0);
1272 __GLX_SWAP_INT(pc + 4);
1273 __GLX_SWAP_INT(pc + 8);
1274
1275 }
1276
1277 void
__glXDispSwap_TexEnviv(GLbyte * pc)1278 __glXDispSwap_TexEnviv(GLbyte * pc)
1279 {
1280 GLenum pname;
1281 GLint compsize;
1282
1283 __GLX_DECLARE_SWAP_VARIABLES;
1284 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1285
1286 __GLX_SWAP_INT(pc + 4);
1287 pname = *(GLenum *) (pc + 4);
1288 compsize = __glTexEnviv_size(pname);
1289 if (compsize < 0)
1290 compsize = 0;
1291 __GLX_SWAP_INT(pc + 0);
1292 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1293
1294 }
1295
1296 void
__glXDispSwap_TexGend(GLbyte * pc)1297 __glXDispSwap_TexGend(GLbyte * pc)
1298 {
1299 __GLX_DECLARE_SWAP_VARIABLES;
1300
1301 #ifdef __GLX_ALIGN64
1302 if ((unsigned long) (pc) & 7) {
1303 __GLX_MEM_COPY(pc - 4, pc, 16);
1304 pc -= 4;
1305 }
1306 #endif
1307 __GLX_SWAP_INT(pc + 8);
1308 __GLX_SWAP_INT(pc + 12);
1309 __GLX_SWAP_DOUBLE(pc + 0);
1310
1311 }
1312
1313 void
__glXDispSwap_TexGendv(GLbyte * pc)1314 __glXDispSwap_TexGendv(GLbyte * pc)
1315 {
1316 GLenum pname;
1317 GLint cmdlen;
1318 GLint compsize;
1319
1320 __GLX_DECLARE_SWAP_VARIABLES;
1321 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1322
1323 __GLX_SWAP_INT(pc + 4);
1324 pname = *(GLenum *) (pc + 4);
1325 compsize = __glTexGendv_size(pname);
1326 if (compsize < 0)
1327 compsize = 0;
1328 cmdlen = __GLX_PAD(8 + compsize * 8);
1329
1330 #ifdef __GLX_ALIGN64
1331 if ((unsigned long) (pc) & 7) {
1332 __GLX_MEM_COPY(pc - 4, pc, cmdlen);
1333 pc -= 4;
1334 }
1335 #endif
1336 __GLX_SWAP_INT(pc + 0);
1337 __GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize);
1338
1339 }
1340
1341 void
__glXDispSwap_TexGenf(GLbyte * pc)1342 __glXDispSwap_TexGenf(GLbyte * pc)
1343 {
1344 __GLX_DECLARE_SWAP_VARIABLES;
1345
1346 __GLX_SWAP_INT(pc + 0);
1347 __GLX_SWAP_INT(pc + 4);
1348 __GLX_SWAP_FLOAT(pc + 8);
1349
1350 }
1351
1352 void
__glXDispSwap_TexGenfv(GLbyte * pc)1353 __glXDispSwap_TexGenfv(GLbyte * pc)
1354 {
1355 GLenum pname;
1356 GLint compsize;
1357
1358 __GLX_DECLARE_SWAP_VARIABLES;
1359 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1360
1361 __GLX_SWAP_INT(pc + 4);
1362 pname = *(GLenum *) (pc + 4);
1363 compsize = __glTexGenfv_size(pname);
1364 if (compsize < 0)
1365 compsize = 0;
1366 __GLX_SWAP_INT(pc + 0);
1367 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1368
1369 }
1370
1371 void
__glXDispSwap_TexGeni(GLbyte * pc)1372 __glXDispSwap_TexGeni(GLbyte * pc)
1373 {
1374 __GLX_DECLARE_SWAP_VARIABLES;
1375
1376 __GLX_SWAP_INT(pc + 0);
1377 __GLX_SWAP_INT(pc + 4);
1378 __GLX_SWAP_INT(pc + 8);
1379
1380 }
1381
1382 void
__glXDispSwap_TexGeniv(GLbyte * pc)1383 __glXDispSwap_TexGeniv(GLbyte * pc)
1384 {
1385 GLenum pname;
1386 GLint compsize;
1387
1388 __GLX_DECLARE_SWAP_VARIABLES;
1389 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1390
1391 __GLX_SWAP_INT(pc + 4);
1392 pname = *(GLenum *) (pc + 4);
1393 compsize = __glTexGeniv_size(pname);
1394 if (compsize < 0)
1395 compsize = 0;
1396 __GLX_SWAP_INT(pc + 0);
1397 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1398
1399 }
1400
1401 void
__glXDispSwap_InitNames(GLbyte * pc)1402 __glXDispSwap_InitNames(GLbyte * pc)
1403 {
1404 }
1405
1406 void
__glXDispSwap_LoadName(GLbyte * pc)1407 __glXDispSwap_LoadName(GLbyte * pc)
1408 {
1409 __GLX_DECLARE_SWAP_VARIABLES;
1410
1411 __GLX_SWAP_INT(pc + 0);
1412
1413 }
1414
1415 void
__glXDispSwap_PassThrough(GLbyte * pc)1416 __glXDispSwap_PassThrough(GLbyte * pc)
1417 {
1418 __GLX_DECLARE_SWAP_VARIABLES;
1419
1420 __GLX_SWAP_FLOAT(pc + 0);
1421
1422 }
1423
1424 void
__glXDispSwap_PopName(GLbyte * pc)1425 __glXDispSwap_PopName(GLbyte * pc)
1426 {
1427 }
1428
1429 void
__glXDispSwap_PushName(GLbyte * pc)1430 __glXDispSwap_PushName(GLbyte * pc)
1431 {
1432 __GLX_DECLARE_SWAP_VARIABLES;
1433
1434 __GLX_SWAP_INT(pc + 0);
1435
1436 }
1437
1438 void
__glXDispSwap_DrawBuffer(GLbyte * pc)1439 __glXDispSwap_DrawBuffer(GLbyte * pc)
1440 {
1441 __GLX_DECLARE_SWAP_VARIABLES;
1442
1443 __GLX_SWAP_INT(pc + 0);
1444
1445 }
1446
1447 void
__glXDispSwap_Clear(GLbyte * pc)1448 __glXDispSwap_Clear(GLbyte * pc)
1449 {
1450 __GLX_DECLARE_SWAP_VARIABLES;
1451
1452 __GLX_SWAP_INT(pc + 0);
1453
1454 }
1455
1456 void
__glXDispSwap_ClearAccum(GLbyte * pc)1457 __glXDispSwap_ClearAccum(GLbyte * pc)
1458 {
1459 __GLX_DECLARE_SWAP_VARIABLES;
1460
1461 __GLX_SWAP_FLOAT(pc + 0);
1462 __GLX_SWAP_FLOAT(pc + 4);
1463 __GLX_SWAP_FLOAT(pc + 8);
1464 __GLX_SWAP_FLOAT(pc + 12);
1465
1466 }
1467
1468 void
__glXDispSwap_ClearIndex(GLbyte * pc)1469 __glXDispSwap_ClearIndex(GLbyte * pc)
1470 {
1471 __GLX_DECLARE_SWAP_VARIABLES;
1472
1473 __GLX_SWAP_FLOAT(pc + 0);
1474
1475 }
1476
1477 void
__glXDispSwap_ClearColor(GLbyte * pc)1478 __glXDispSwap_ClearColor(GLbyte * pc)
1479 {
1480 __GLX_DECLARE_SWAP_VARIABLES;
1481
1482 __GLX_SWAP_FLOAT(pc + 0);
1483 __GLX_SWAP_FLOAT(pc + 4);
1484 __GLX_SWAP_FLOAT(pc + 8);
1485 __GLX_SWAP_FLOAT(pc + 12);
1486
1487 }
1488
1489 void
__glXDispSwap_ClearStencil(GLbyte * pc)1490 __glXDispSwap_ClearStencil(GLbyte * pc)
1491 {
1492 __GLX_DECLARE_SWAP_VARIABLES;
1493
1494 __GLX_SWAP_INT(pc + 0);
1495
1496 }
1497
1498 void
__glXDispSwap_ClearDepth(GLbyte * pc)1499 __glXDispSwap_ClearDepth(GLbyte * pc)
1500 {
1501 __GLX_DECLARE_SWAP_VARIABLES;
1502
1503 #ifdef __GLX_ALIGN64
1504 if ((unsigned long) (pc) & 7) {
1505 __GLX_MEM_COPY(pc - 4, pc, 8);
1506 pc -= 4;
1507 }
1508 #endif
1509 __GLX_SWAP_DOUBLE(pc + 0);
1510
1511 }
1512
1513 void
__glXDispSwap_StencilMask(GLbyte * pc)1514 __glXDispSwap_StencilMask(GLbyte * pc)
1515 {
1516 __GLX_DECLARE_SWAP_VARIABLES;
1517
1518 __GLX_SWAP_INT(pc + 0);
1519
1520 }
1521
1522 void
__glXDispSwap_ColorMask(GLbyte * pc)1523 __glXDispSwap_ColorMask(GLbyte * pc)
1524 {
1525 }
1526
1527 void
__glXDispSwap_DepthMask(GLbyte * pc)1528 __glXDispSwap_DepthMask(GLbyte * pc)
1529 {
1530 }
1531
1532 void
__glXDispSwap_IndexMask(GLbyte * pc)1533 __glXDispSwap_IndexMask(GLbyte * pc)
1534 {
1535 __GLX_DECLARE_SWAP_VARIABLES;
1536
1537 __GLX_SWAP_INT(pc + 0);
1538
1539 }
1540
1541 void
__glXDispSwap_Accum(GLbyte * pc)1542 __glXDispSwap_Accum(GLbyte * pc)
1543 {
1544 __GLX_DECLARE_SWAP_VARIABLES;
1545
1546 __GLX_SWAP_INT(pc + 0);
1547 __GLX_SWAP_FLOAT(pc + 4);
1548
1549 }
1550
1551 void
__glXDispSwap_Disable(GLbyte * pc)1552 __glXDispSwap_Disable(GLbyte * pc)
1553 {
1554 __GLX_DECLARE_SWAP_VARIABLES;
1555
1556 __GLX_SWAP_INT(pc + 0);
1557
1558 }
1559
1560 void
__glXDispSwap_Enable(GLbyte * pc)1561 __glXDispSwap_Enable(GLbyte * pc)
1562 {
1563 __GLX_DECLARE_SWAP_VARIABLES;
1564
1565 __GLX_SWAP_INT(pc + 0);
1566
1567 }
1568
1569 void
__glXDispSwap_PopAttrib(GLbyte * pc)1570 __glXDispSwap_PopAttrib(GLbyte * pc)
1571 {
1572 }
1573
1574 void
__glXDispSwap_PushAttrib(GLbyte * pc)1575 __glXDispSwap_PushAttrib(GLbyte * pc)
1576 {
1577 __GLX_DECLARE_SWAP_VARIABLES;
1578
1579 __GLX_SWAP_INT(pc + 0);
1580
1581 }
1582
1583 void
__glXDispSwap_MapGrid1d(GLbyte * pc)1584 __glXDispSwap_MapGrid1d(GLbyte * pc)
1585 {
1586 __GLX_DECLARE_SWAP_VARIABLES;
1587
1588 #ifdef __GLX_ALIGN64
1589 if ((unsigned long) (pc) & 7) {
1590 __GLX_MEM_COPY(pc - 4, pc, 20);
1591 pc -= 4;
1592 }
1593 #endif
1594 __GLX_SWAP_INT(pc + 16);
1595 __GLX_SWAP_DOUBLE(pc + 0);
1596 __GLX_SWAP_DOUBLE(pc + 8);
1597
1598 }
1599
1600 void
__glXDispSwap_MapGrid1f(GLbyte * pc)1601 __glXDispSwap_MapGrid1f(GLbyte * pc)
1602 {
1603 __GLX_DECLARE_SWAP_VARIABLES;
1604
1605 __GLX_SWAP_INT(pc + 0);
1606 __GLX_SWAP_FLOAT(pc + 4);
1607 __GLX_SWAP_FLOAT(pc + 8);
1608
1609 }
1610
1611 void
__glXDispSwap_MapGrid2d(GLbyte * pc)1612 __glXDispSwap_MapGrid2d(GLbyte * pc)
1613 {
1614 __GLX_DECLARE_SWAP_VARIABLES;
1615
1616 #ifdef __GLX_ALIGN64
1617 if ((unsigned long) (pc) & 7) {
1618 __GLX_MEM_COPY(pc - 4, pc, 40);
1619 pc -= 4;
1620 }
1621 #endif
1622 __GLX_SWAP_INT(pc + 32);
1623 __GLX_SWAP_DOUBLE(pc + 0);
1624 __GLX_SWAP_DOUBLE(pc + 8);
1625 __GLX_SWAP_INT(pc + 36);
1626 __GLX_SWAP_DOUBLE(pc + 16);
1627 __GLX_SWAP_DOUBLE(pc + 24);
1628
1629 }
1630
1631 void
__glXDispSwap_MapGrid2f(GLbyte * pc)1632 __glXDispSwap_MapGrid2f(GLbyte * pc)
1633 {
1634 __GLX_DECLARE_SWAP_VARIABLES;
1635
1636 __GLX_SWAP_INT(pc + 0);
1637 __GLX_SWAP_FLOAT(pc + 4);
1638 __GLX_SWAP_FLOAT(pc + 8);
1639 __GLX_SWAP_INT(pc + 12);
1640 __GLX_SWAP_FLOAT(pc + 16);
1641 __GLX_SWAP_FLOAT(pc + 20);
1642
1643 }
1644
1645 void
__glXDispSwap_EvalCoord1dv(GLbyte * pc)1646 __glXDispSwap_EvalCoord1dv(GLbyte * pc)
1647 {
1648 __GLX_DECLARE_SWAP_VARIABLES;
1649 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1650
1651 #ifdef __GLX_ALIGN64
1652 if ((unsigned long) (pc) & 7) {
1653 __GLX_MEM_COPY(pc - 4, pc, 8);
1654 pc -= 4;
1655 }
1656 #endif
1657 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
1658
1659 }
1660
1661 void
__glXDispSwap_EvalCoord1fv(GLbyte * pc)1662 __glXDispSwap_EvalCoord1fv(GLbyte * pc)
1663 {
1664 __GLX_DECLARE_SWAP_VARIABLES;
1665 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1666
1667 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
1668
1669 }
1670
1671 void
__glXDispSwap_EvalCoord2dv(GLbyte * pc)1672 __glXDispSwap_EvalCoord2dv(GLbyte * pc)
1673 {
1674 __GLX_DECLARE_SWAP_VARIABLES;
1675 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1676
1677 #ifdef __GLX_ALIGN64
1678 if ((unsigned long) (pc) & 7) {
1679 __GLX_MEM_COPY(pc - 4, pc, 16);
1680 pc -= 4;
1681 }
1682 #endif
1683 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
1684
1685 }
1686
1687 void
__glXDispSwap_EvalCoord2fv(GLbyte * pc)1688 __glXDispSwap_EvalCoord2fv(GLbyte * pc)
1689 {
1690 __GLX_DECLARE_SWAP_VARIABLES;
1691 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1692
1693 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
1694
1695 }
1696
1697 void
__glXDispSwap_EvalMesh1(GLbyte * pc)1698 __glXDispSwap_EvalMesh1(GLbyte * pc)
1699 {
1700 __GLX_DECLARE_SWAP_VARIABLES;
1701
1702 __GLX_SWAP_INT(pc + 0);
1703 __GLX_SWAP_INT(pc + 4);
1704 __GLX_SWAP_INT(pc + 8);
1705
1706 }
1707
1708 void
__glXDispSwap_EvalPoint1(GLbyte * pc)1709 __glXDispSwap_EvalPoint1(GLbyte * pc)
1710 {
1711 __GLX_DECLARE_SWAP_VARIABLES;
1712
1713 __GLX_SWAP_INT(pc + 0);
1714
1715 }
1716
1717 void
__glXDispSwap_EvalMesh2(GLbyte * pc)1718 __glXDispSwap_EvalMesh2(GLbyte * pc)
1719 {
1720 __GLX_DECLARE_SWAP_VARIABLES;
1721
1722 __GLX_SWAP_INT(pc + 0);
1723 __GLX_SWAP_INT(pc + 4);
1724 __GLX_SWAP_INT(pc + 8);
1725 __GLX_SWAP_INT(pc + 12);
1726 __GLX_SWAP_INT(pc + 16);
1727
1728 }
1729
1730 void
__glXDispSwap_EvalPoint2(GLbyte * pc)1731 __glXDispSwap_EvalPoint2(GLbyte * pc)
1732 {
1733 __GLX_DECLARE_SWAP_VARIABLES;
1734
1735 __GLX_SWAP_INT(pc + 0);
1736 __GLX_SWAP_INT(pc + 4);
1737
1738 }
1739
1740 void
__glXDispSwap_AlphaFunc(GLbyte * pc)1741 __glXDispSwap_AlphaFunc(GLbyte * pc)
1742 {
1743 __GLX_DECLARE_SWAP_VARIABLES;
1744
1745 __GLX_SWAP_INT(pc + 0);
1746 __GLX_SWAP_FLOAT(pc + 4);
1747
1748 }
1749
1750 void
__glXDispSwap_BlendFunc(GLbyte * pc)1751 __glXDispSwap_BlendFunc(GLbyte * pc)
1752 {
1753 __GLX_DECLARE_SWAP_VARIABLES;
1754
1755 __GLX_SWAP_INT(pc + 0);
1756 __GLX_SWAP_INT(pc + 4);
1757
1758 }
1759
1760 void
__glXDispSwap_LogicOp(GLbyte * pc)1761 __glXDispSwap_LogicOp(GLbyte * pc)
1762 {
1763 __GLX_DECLARE_SWAP_VARIABLES;
1764
1765 __GLX_SWAP_INT(pc + 0);
1766
1767 }
1768
1769 void
__glXDispSwap_StencilFunc(GLbyte * pc)1770 __glXDispSwap_StencilFunc(GLbyte * pc)
1771 {
1772 __GLX_DECLARE_SWAP_VARIABLES;
1773
1774 __GLX_SWAP_INT(pc + 0);
1775 __GLX_SWAP_INT(pc + 4);
1776 __GLX_SWAP_INT(pc + 8);
1777
1778 }
1779
1780 void
__glXDispSwap_StencilOp(GLbyte * pc)1781 __glXDispSwap_StencilOp(GLbyte * pc)
1782 {
1783 __GLX_DECLARE_SWAP_VARIABLES;
1784
1785 __GLX_SWAP_INT(pc + 0);
1786 __GLX_SWAP_INT(pc + 4);
1787 __GLX_SWAP_INT(pc + 8);
1788
1789 }
1790
1791 void
__glXDispSwap_DepthFunc(GLbyte * pc)1792 __glXDispSwap_DepthFunc(GLbyte * pc)
1793 {
1794 __GLX_DECLARE_SWAP_VARIABLES;
1795
1796 __GLX_SWAP_INT(pc + 0);
1797
1798 }
1799
1800 void
__glXDispSwap_PixelZoom(GLbyte * pc)1801 __glXDispSwap_PixelZoom(GLbyte * pc)
1802 {
1803 __GLX_DECLARE_SWAP_VARIABLES;
1804
1805 __GLX_SWAP_FLOAT(pc + 0);
1806 __GLX_SWAP_FLOAT(pc + 4);
1807
1808 }
1809
1810 void
__glXDispSwap_PixelTransferf(GLbyte * pc)1811 __glXDispSwap_PixelTransferf(GLbyte * pc)
1812 {
1813 __GLX_DECLARE_SWAP_VARIABLES;
1814
1815 __GLX_SWAP_INT(pc + 0);
1816 __GLX_SWAP_FLOAT(pc + 4);
1817
1818 }
1819
1820 void
__glXDispSwap_PixelTransferi(GLbyte * pc)1821 __glXDispSwap_PixelTransferi(GLbyte * pc)
1822 {
1823 __GLX_DECLARE_SWAP_VARIABLES;
1824
1825 __GLX_SWAP_INT(pc + 0);
1826 __GLX_SWAP_INT(pc + 4);
1827
1828 }
1829
1830 void
__glXDispSwap_PixelMapfv(GLbyte * pc)1831 __glXDispSwap_PixelMapfv(GLbyte * pc)
1832 {
1833 GLint mapsize;
1834
1835 __GLX_DECLARE_SWAP_VARIABLES;
1836 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1837
1838 __GLX_SWAP_INT(pc + 4);
1839 mapsize = *(GLint *) (pc + 4);
1840 __GLX_SWAP_INT(pc + 0);
1841 __GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize);
1842
1843 }
1844
1845 void
__glXDispSwap_PixelMapuiv(GLbyte * pc)1846 __glXDispSwap_PixelMapuiv(GLbyte * pc)
1847 {
1848 GLint mapsize;
1849
1850 __GLX_DECLARE_SWAP_VARIABLES;
1851 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1852
1853 __GLX_SWAP_INT(pc + 4);
1854 mapsize = *(GLint *) (pc + 4);
1855 __GLX_SWAP_INT(pc + 0);
1856 __GLX_SWAP_INT_ARRAY(pc + 8, mapsize);
1857
1858 }
1859
1860 void
__glXDispSwap_PixelMapusv(GLbyte * pc)1861 __glXDispSwap_PixelMapusv(GLbyte * pc)
1862 {
1863 GLint mapsize;
1864
1865 __GLX_DECLARE_SWAP_VARIABLES;
1866 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1867
1868 __GLX_SWAP_INT(pc + 4);
1869 mapsize = *(GLint *) (pc + 4);
1870 __GLX_SWAP_INT(pc + 0);
1871 __GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize);
1872
1873 }
1874
1875 void
__glXDispSwap_ReadBuffer(GLbyte * pc)1876 __glXDispSwap_ReadBuffer(GLbyte * pc)
1877 {
1878 __GLX_DECLARE_SWAP_VARIABLES;
1879
1880 __GLX_SWAP_INT(pc + 0);
1881
1882 }
1883
1884 void
__glXDispSwap_CopyPixels(GLbyte * pc)1885 __glXDispSwap_CopyPixels(GLbyte * pc)
1886 {
1887 __GLX_DECLARE_SWAP_VARIABLES;
1888
1889 __GLX_SWAP_INT(pc + 0);
1890 __GLX_SWAP_INT(pc + 4);
1891 __GLX_SWAP_INT(pc + 8);
1892 __GLX_SWAP_INT(pc + 12);
1893 __GLX_SWAP_INT(pc + 16);
1894
1895 }
1896
1897 void
__glXDispSwap_DepthRange(GLbyte * pc)1898 __glXDispSwap_DepthRange(GLbyte * pc)
1899 {
1900 __GLX_DECLARE_SWAP_VARIABLES;
1901
1902 #ifdef __GLX_ALIGN64
1903 if ((unsigned long) (pc) & 7) {
1904 __GLX_MEM_COPY(pc - 4, pc, 16);
1905 pc -= 4;
1906 }
1907 #endif
1908 __GLX_SWAP_DOUBLE(pc + 0);
1909 __GLX_SWAP_DOUBLE(pc + 8);
1910
1911 }
1912
1913 void
__glXDispSwap_Frustum(GLbyte * pc)1914 __glXDispSwap_Frustum(GLbyte * pc)
1915 {
1916 __GLX_DECLARE_SWAP_VARIABLES;
1917
1918 #ifdef __GLX_ALIGN64
1919 if ((unsigned long) (pc) & 7) {
1920 __GLX_MEM_COPY(pc - 4, pc, 48);
1921 pc -= 4;
1922 }
1923 #endif
1924 __GLX_SWAP_DOUBLE(pc + 0);
1925 __GLX_SWAP_DOUBLE(pc + 8);
1926 __GLX_SWAP_DOUBLE(pc + 16);
1927 __GLX_SWAP_DOUBLE(pc + 24);
1928 __GLX_SWAP_DOUBLE(pc + 32);
1929 __GLX_SWAP_DOUBLE(pc + 40);
1930
1931 }
1932
1933 void
__glXDispSwap_LoadIdentity(GLbyte * pc)1934 __glXDispSwap_LoadIdentity(GLbyte * pc)
1935 {
1936 }
1937
1938 void
__glXDispSwap_LoadMatrixf(GLbyte * pc)1939 __glXDispSwap_LoadMatrixf(GLbyte * pc)
1940 {
1941 __GLX_DECLARE_SWAP_VARIABLES;
1942 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1943
1944 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
1945
1946 }
1947
1948 void
__glXDispSwap_LoadMatrixd(GLbyte * pc)1949 __glXDispSwap_LoadMatrixd(GLbyte * pc)
1950 {
1951 __GLX_DECLARE_SWAP_VARIABLES;
1952 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1953
1954 #ifdef __GLX_ALIGN64
1955 if ((unsigned long) (pc) & 7) {
1956 __GLX_MEM_COPY(pc - 4, pc, 128);
1957 pc -= 4;
1958 }
1959 #endif
1960 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
1961
1962 }
1963
1964 void
__glXDispSwap_MatrixMode(GLbyte * pc)1965 __glXDispSwap_MatrixMode(GLbyte * pc)
1966 {
1967 __GLX_DECLARE_SWAP_VARIABLES;
1968
1969 __GLX_SWAP_INT(pc + 0);
1970
1971 }
1972
1973 void
__glXDispSwap_MultMatrixf(GLbyte * pc)1974 __glXDispSwap_MultMatrixf(GLbyte * pc)
1975 {
1976 __GLX_DECLARE_SWAP_VARIABLES;
1977 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1978
1979 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
1980
1981 }
1982
1983 void
__glXDispSwap_MultMatrixd(GLbyte * pc)1984 __glXDispSwap_MultMatrixd(GLbyte * pc)
1985 {
1986 __GLX_DECLARE_SWAP_VARIABLES;
1987 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1988
1989 #ifdef __GLX_ALIGN64
1990 if ((unsigned long) (pc) & 7) {
1991 __GLX_MEM_COPY(pc - 4, pc, 128);
1992 pc -= 4;
1993 }
1994 #endif
1995 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
1996
1997 }
1998
1999 void
__glXDispSwap_Ortho(GLbyte * pc)2000 __glXDispSwap_Ortho(GLbyte * pc)
2001 {
2002 __GLX_DECLARE_SWAP_VARIABLES;
2003
2004 #ifdef __GLX_ALIGN64
2005 if ((unsigned long) (pc) & 7) {
2006 __GLX_MEM_COPY(pc - 4, pc, 48);
2007 pc -= 4;
2008 }
2009 #endif
2010 __GLX_SWAP_DOUBLE(pc + 0);
2011 __GLX_SWAP_DOUBLE(pc + 8);
2012 __GLX_SWAP_DOUBLE(pc + 16);
2013 __GLX_SWAP_DOUBLE(pc + 24);
2014 __GLX_SWAP_DOUBLE(pc + 32);
2015 __GLX_SWAP_DOUBLE(pc + 40);
2016
2017 }
2018
2019 void
__glXDispSwap_PopMatrix(GLbyte * pc)2020 __glXDispSwap_PopMatrix(GLbyte * pc)
2021 {
2022 }
2023
2024 void
__glXDispSwap_PushMatrix(GLbyte * pc)2025 __glXDispSwap_PushMatrix(GLbyte * pc)
2026 {
2027 }
2028
2029 void
__glXDispSwap_Rotated(GLbyte * pc)2030 __glXDispSwap_Rotated(GLbyte * pc)
2031 {
2032 __GLX_DECLARE_SWAP_VARIABLES;
2033
2034 #ifdef __GLX_ALIGN64
2035 if ((unsigned long) (pc) & 7) {
2036 __GLX_MEM_COPY(pc - 4, pc, 32);
2037 pc -= 4;
2038 }
2039 #endif
2040 __GLX_SWAP_DOUBLE(pc + 0);
2041 __GLX_SWAP_DOUBLE(pc + 8);
2042 __GLX_SWAP_DOUBLE(pc + 16);
2043 __GLX_SWAP_DOUBLE(pc + 24);
2044
2045 }
2046
2047 void
__glXDispSwap_Rotatef(GLbyte * pc)2048 __glXDispSwap_Rotatef(GLbyte * pc)
2049 {
2050 __GLX_DECLARE_SWAP_VARIABLES;
2051
2052 __GLX_SWAP_FLOAT(pc + 0);
2053 __GLX_SWAP_FLOAT(pc + 4);
2054 __GLX_SWAP_FLOAT(pc + 8);
2055 __GLX_SWAP_FLOAT(pc + 12);
2056
2057 }
2058
2059 void
__glXDispSwap_Scaled(GLbyte * pc)2060 __glXDispSwap_Scaled(GLbyte * pc)
2061 {
2062 __GLX_DECLARE_SWAP_VARIABLES;
2063
2064 #ifdef __GLX_ALIGN64
2065 if ((unsigned long) (pc) & 7) {
2066 __GLX_MEM_COPY(pc - 4, pc, 24);
2067 pc -= 4;
2068 }
2069 #endif
2070 __GLX_SWAP_DOUBLE(pc + 0);
2071 __GLX_SWAP_DOUBLE(pc + 8);
2072 __GLX_SWAP_DOUBLE(pc + 16);
2073
2074 }
2075
2076 void
__glXDispSwap_Scalef(GLbyte * pc)2077 __glXDispSwap_Scalef(GLbyte * pc)
2078 {
2079 __GLX_DECLARE_SWAP_VARIABLES;
2080
2081 __GLX_SWAP_FLOAT(pc + 0);
2082 __GLX_SWAP_FLOAT(pc + 4);
2083 __GLX_SWAP_FLOAT(pc + 8);
2084
2085 }
2086
2087 void
__glXDispSwap_Translated(GLbyte * pc)2088 __glXDispSwap_Translated(GLbyte * pc)
2089 {
2090 __GLX_DECLARE_SWAP_VARIABLES;
2091
2092 #ifdef __GLX_ALIGN64
2093 if ((unsigned long) (pc) & 7) {
2094 __GLX_MEM_COPY(pc - 4, pc, 24);
2095 pc -= 4;
2096 }
2097 #endif
2098 __GLX_SWAP_DOUBLE(pc + 0);
2099 __GLX_SWAP_DOUBLE(pc + 8);
2100 __GLX_SWAP_DOUBLE(pc + 16);
2101
2102 }
2103
2104 void
__glXDispSwap_Translatef(GLbyte * pc)2105 __glXDispSwap_Translatef(GLbyte * pc)
2106 {
2107 __GLX_DECLARE_SWAP_VARIABLES;
2108
2109 __GLX_SWAP_FLOAT(pc + 0);
2110 __GLX_SWAP_FLOAT(pc + 4);
2111 __GLX_SWAP_FLOAT(pc + 8);
2112
2113 }
2114
2115 void
__glXDispSwap_Viewport(GLbyte * pc)2116 __glXDispSwap_Viewport(GLbyte * pc)
2117 {
2118 __GLX_DECLARE_SWAP_VARIABLES;
2119
2120 __GLX_SWAP_INT(pc + 0);
2121 __GLX_SWAP_INT(pc + 4);
2122 __GLX_SWAP_INT(pc + 8);
2123 __GLX_SWAP_INT(pc + 12);
2124
2125 }
2126
2127 void
__glXDispSwap_PolygonOffset(GLbyte * pc)2128 __glXDispSwap_PolygonOffset(GLbyte * pc)
2129 {
2130 __GLX_DECLARE_SWAP_VARIABLES;
2131
2132 __GLX_SWAP_FLOAT(pc + 0);
2133 __GLX_SWAP_FLOAT(pc + 4);
2134
2135 }
2136
2137 void
__glXDispSwap_CopyTexImage1D(GLbyte * pc)2138 __glXDispSwap_CopyTexImage1D(GLbyte * pc)
2139 {
2140 __GLX_DECLARE_SWAP_VARIABLES;
2141
2142 __GLX_SWAP_INT(pc + 0);
2143 __GLX_SWAP_INT(pc + 4);
2144 __GLX_SWAP_INT(pc + 8);
2145 __GLX_SWAP_INT(pc + 12);
2146 __GLX_SWAP_INT(pc + 16);
2147 __GLX_SWAP_INT(pc + 20);
2148 __GLX_SWAP_INT(pc + 24);
2149
2150 }
2151
2152 void
__glXDispSwap_CopyTexImage2D(GLbyte * pc)2153 __glXDispSwap_CopyTexImage2D(GLbyte * pc)
2154 {
2155 __GLX_DECLARE_SWAP_VARIABLES;
2156
2157 __GLX_SWAP_INT(pc + 0);
2158 __GLX_SWAP_INT(pc + 4);
2159 __GLX_SWAP_INT(pc + 8);
2160 __GLX_SWAP_INT(pc + 12);
2161 __GLX_SWAP_INT(pc + 16);
2162 __GLX_SWAP_INT(pc + 20);
2163 __GLX_SWAP_INT(pc + 24);
2164 __GLX_SWAP_INT(pc + 28);
2165
2166 }
2167
2168 void
__glXDispSwap_CopyTexSubImage1D(GLbyte * pc)2169 __glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
2170 {
2171 __GLX_DECLARE_SWAP_VARIABLES;
2172
2173 __GLX_SWAP_INT(pc + 0);
2174 __GLX_SWAP_INT(pc + 4);
2175 __GLX_SWAP_INT(pc + 8);
2176 __GLX_SWAP_INT(pc + 12);
2177 __GLX_SWAP_INT(pc + 16);
2178 __GLX_SWAP_INT(pc + 20);
2179
2180 }
2181
2182 void
__glXDispSwap_CopyTexSubImage2D(GLbyte * pc)2183 __glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
2184 {
2185 __GLX_DECLARE_SWAP_VARIABLES;
2186
2187 __GLX_SWAP_INT(pc + 0);
2188 __GLX_SWAP_INT(pc + 4);
2189 __GLX_SWAP_INT(pc + 8);
2190 __GLX_SWAP_INT(pc + 12);
2191 __GLX_SWAP_INT(pc + 16);
2192 __GLX_SWAP_INT(pc + 20);
2193 __GLX_SWAP_INT(pc + 24);
2194 __GLX_SWAP_INT(pc + 28);
2195
2196 }
2197
2198 void
__glXDispSwap_BindTexture(GLbyte * pc)2199 __glXDispSwap_BindTexture(GLbyte * pc)
2200 {
2201 __GLX_DECLARE_SWAP_VARIABLES;
2202
2203 __GLX_SWAP_INT(pc + 0);
2204 __GLX_SWAP_INT(pc + 4);
2205
2206 }
2207
2208 void
__glXDispSwap_PrioritizeTextures(GLbyte * pc)2209 __glXDispSwap_PrioritizeTextures(GLbyte * pc)
2210 {
2211 GLsizei n;
2212
2213 __GLX_DECLARE_SWAP_VARIABLES;
2214 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2215
2216 __GLX_SWAP_INT(pc + 0);
2217 n = *(GLsizei *) (pc + 0);
2218 __GLX_SWAP_INT_ARRAY(pc + 4, n);
2219 __GLX_SWAP_FLOAT_ARRAY(pc + 4 + n * 4, n);
2220
2221 }
2222
2223 void
__glXDispSwap_Indexubv(GLbyte * pc)2224 __glXDispSwap_Indexubv(GLbyte * pc)
2225 {
2226 }
2227
2228 void
__glXDispSwap_BlendColor(GLbyte * pc)2229 __glXDispSwap_BlendColor(GLbyte * pc)
2230 {
2231 __GLX_DECLARE_SWAP_VARIABLES;
2232
2233 __GLX_SWAP_FLOAT(pc + 0);
2234 __GLX_SWAP_FLOAT(pc + 4);
2235 __GLX_SWAP_FLOAT(pc + 8);
2236 __GLX_SWAP_FLOAT(pc + 12);
2237
2238 }
2239
2240 void
__glXDispSwap_BlendEquation(GLbyte * pc)2241 __glXDispSwap_BlendEquation(GLbyte * pc)
2242 {
2243 __GLX_DECLARE_SWAP_VARIABLES;
2244
2245 __GLX_SWAP_INT(pc + 0);
2246
2247 }
2248
2249 void
__glXDispSwap_ColorTableParameterfv(GLbyte * pc)2250 __glXDispSwap_ColorTableParameterfv(GLbyte * pc)
2251 {
2252 GLenum pname;
2253 GLint compsize;
2254
2255 __GLX_DECLARE_SWAP_VARIABLES;
2256 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2257
2258 __GLX_SWAP_INT(pc + 4);
2259 pname = *(GLenum *) (pc + 4);
2260 compsize = __glColorTableParameterfv_size(pname);
2261 if (compsize < 0)
2262 compsize = 0;
2263 __GLX_SWAP_INT(pc + 0);
2264 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
2265
2266 }
2267
2268 void
__glXDispSwap_ColorTableParameteriv(GLbyte * pc)2269 __glXDispSwap_ColorTableParameteriv(GLbyte * pc)
2270 {
2271 GLenum pname;
2272 GLint compsize;
2273
2274 __GLX_DECLARE_SWAP_VARIABLES;
2275 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2276
2277 __GLX_SWAP_INT(pc + 4);
2278 pname = *(GLenum *) (pc + 4);
2279 compsize = __glColorTableParameteriv_size(pname);
2280 if (compsize < 0)
2281 compsize = 0;
2282 __GLX_SWAP_INT(pc + 0);
2283 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
2284
2285 }
2286
2287 void
__glXDispSwap_CopyColorTable(GLbyte * pc)2288 __glXDispSwap_CopyColorTable(GLbyte * pc)
2289 {
2290 __GLX_DECLARE_SWAP_VARIABLES;
2291
2292 __GLX_SWAP_INT(pc + 0);
2293 __GLX_SWAP_INT(pc + 4);
2294 __GLX_SWAP_INT(pc + 8);
2295 __GLX_SWAP_INT(pc + 12);
2296 __GLX_SWAP_INT(pc + 16);
2297
2298 }
2299
2300 void
__glXDispSwap_CopyColorSubTable(GLbyte * pc)2301 __glXDispSwap_CopyColorSubTable(GLbyte * pc)
2302 {
2303 __GLX_DECLARE_SWAP_VARIABLES;
2304
2305 __GLX_SWAP_INT(pc + 0);
2306 __GLX_SWAP_INT(pc + 4);
2307 __GLX_SWAP_INT(pc + 8);
2308 __GLX_SWAP_INT(pc + 12);
2309 __GLX_SWAP_INT(pc + 16);
2310
2311 }
2312
2313 void
__glXDispSwap_ConvolutionParameterf(GLbyte * pc)2314 __glXDispSwap_ConvolutionParameterf(GLbyte * pc)
2315 {
2316 __GLX_DECLARE_SWAP_VARIABLES;
2317
2318 __GLX_SWAP_INT(pc + 0);
2319 __GLX_SWAP_INT(pc + 4);
2320 __GLX_SWAP_FLOAT(pc + 8);
2321
2322 }
2323
2324 void
__glXDispSwap_ConvolutionParameterfv(GLbyte * pc)2325 __glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
2326 {
2327 GLenum pname;
2328 GLint compsize;
2329
2330 __GLX_DECLARE_SWAP_VARIABLES;
2331 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2332
2333 __GLX_SWAP_INT(pc + 4);
2334 pname = *(GLenum *) (pc + 4);
2335 compsize = __glConvolutionParameterfv_size(pname);
2336 if (compsize < 0)
2337 compsize = 0;
2338 __GLX_SWAP_INT(pc + 0);
2339 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
2340
2341 }
2342
2343 void
__glXDispSwap_ConvolutionParameteri(GLbyte * pc)2344 __glXDispSwap_ConvolutionParameteri(GLbyte * pc)
2345 {
2346 __GLX_DECLARE_SWAP_VARIABLES;
2347
2348 __GLX_SWAP_INT(pc + 0);
2349 __GLX_SWAP_INT(pc + 4);
2350 __GLX_SWAP_INT(pc + 8);
2351
2352 }
2353
2354 void
__glXDispSwap_ConvolutionParameteriv(GLbyte * pc)2355 __glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
2356 {
2357 GLenum pname;
2358 GLint compsize;
2359
2360 __GLX_DECLARE_SWAP_VARIABLES;
2361 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2362
2363 __GLX_SWAP_INT(pc + 4);
2364 pname = *(GLenum *) (pc + 4);
2365 compsize = __glConvolutionParameteriv_size(pname);
2366 if (compsize < 0)
2367 compsize = 0;
2368 __GLX_SWAP_INT(pc + 0);
2369 __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
2370
2371 }
2372
2373 void
__glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)2374 __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
2375 {
2376 __GLX_DECLARE_SWAP_VARIABLES;
2377
2378 __GLX_SWAP_INT(pc + 0);
2379 __GLX_SWAP_INT(pc + 4);
2380 __GLX_SWAP_INT(pc + 8);
2381 __GLX_SWAP_INT(pc + 12);
2382 __GLX_SWAP_INT(pc + 16);
2383
2384 }
2385
2386 void
__glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)2387 __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
2388 {
2389 __GLX_DECLARE_SWAP_VARIABLES;
2390
2391 __GLX_SWAP_INT(pc + 0);
2392 __GLX_SWAP_INT(pc + 4);
2393 __GLX_SWAP_INT(pc + 8);
2394 __GLX_SWAP_INT(pc + 12);
2395 __GLX_SWAP_INT(pc + 16);
2396 __GLX_SWAP_INT(pc + 20);
2397
2398 }
2399
2400 void
__glXDispSwap_Histogram(GLbyte * pc)2401 __glXDispSwap_Histogram(GLbyte * pc)
2402 {
2403 __GLX_DECLARE_SWAP_VARIABLES;
2404
2405 __GLX_SWAP_INT(pc + 0);
2406 __GLX_SWAP_INT(pc + 4);
2407 __GLX_SWAP_INT(pc + 8);
2408
2409 }
2410
2411 void
__glXDispSwap_Minmax(GLbyte * pc)2412 __glXDispSwap_Minmax(GLbyte * pc)
2413 {
2414 __GLX_DECLARE_SWAP_VARIABLES;
2415
2416 __GLX_SWAP_INT(pc + 0);
2417 __GLX_SWAP_INT(pc + 4);
2418
2419 }
2420
2421 void
__glXDispSwap_ResetHistogram(GLbyte * pc)2422 __glXDispSwap_ResetHistogram(GLbyte * pc)
2423 {
2424 __GLX_DECLARE_SWAP_VARIABLES;
2425
2426 __GLX_SWAP_INT(pc + 0);
2427
2428 }
2429
2430 void
__glXDispSwap_ResetMinmax(GLbyte * pc)2431 __glXDispSwap_ResetMinmax(GLbyte * pc)
2432 {
2433 __GLX_DECLARE_SWAP_VARIABLES;
2434
2435 __GLX_SWAP_INT(pc + 0);
2436
2437 }
2438
2439 void
__glXDispSwap_CopyTexSubImage3D(GLbyte * pc)2440 __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
2441 {
2442 __GLX_DECLARE_SWAP_VARIABLES;
2443
2444 __GLX_SWAP_INT(pc + 0);
2445 __GLX_SWAP_INT(pc + 4);
2446 __GLX_SWAP_INT(pc + 8);
2447 __GLX_SWAP_INT(pc + 12);
2448 __GLX_SWAP_INT(pc + 16);
2449 __GLX_SWAP_INT(pc + 20);
2450 __GLX_SWAP_INT(pc + 24);
2451 __GLX_SWAP_INT(pc + 28);
2452 __GLX_SWAP_INT(pc + 32);
2453
2454 }
2455
2456 void
__glXDispSwap_ActiveTextureARB(GLbyte * pc)2457 __glXDispSwap_ActiveTextureARB(GLbyte * pc)
2458 {
2459 __GLX_DECLARE_SWAP_VARIABLES;
2460
2461 __GLX_SWAP_INT(pc + 0);
2462
2463 }
2464
2465 void
__glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc)2466 __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc)
2467 {
2468 __GLX_DECLARE_SWAP_VARIABLES;
2469 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2470
2471 #ifdef __GLX_ALIGN64
2472 if ((unsigned long) (pc) & 7) {
2473 __GLX_MEM_COPY(pc - 4, pc, 12);
2474 pc -= 4;
2475 }
2476 #endif
2477 __GLX_SWAP_INT(pc + 8);
2478 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
2479
2480 }
2481
2482 void
__glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)2483 __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
2484 {
2485 __GLX_DECLARE_SWAP_VARIABLES;
2486 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2487
2488 __GLX_SWAP_INT(pc + 0);
2489 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);
2490
2491 }
2492
2493 void
__glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc)2494 __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc)
2495 {
2496 __GLX_DECLARE_SWAP_VARIABLES;
2497 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2498
2499 __GLX_SWAP_INT(pc + 0);
2500 __GLX_SWAP_INT_ARRAY(pc + 4, 1);
2501
2502 }
2503
2504 void
__glXDispSwap_MultiTexCoord1svARB(GLbyte * pc)2505 __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc)
2506 {
2507 __GLX_DECLARE_SWAP_VARIABLES;
2508 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2509
2510 __GLX_SWAP_INT(pc + 0);
2511 __GLX_SWAP_SHORT_ARRAY(pc + 4, 1);
2512
2513 }
2514
2515 void
__glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc)2516 __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc)
2517 {
2518 __GLX_DECLARE_SWAP_VARIABLES;
2519 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2520
2521 #ifdef __GLX_ALIGN64
2522 if ((unsigned long) (pc) & 7) {
2523 __GLX_MEM_COPY(pc - 4, pc, 20);
2524 pc -= 4;
2525 }
2526 #endif
2527 __GLX_SWAP_INT(pc + 16);
2528 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
2529
2530 }
2531
2532 void
__glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)2533 __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
2534 {
2535 __GLX_DECLARE_SWAP_VARIABLES;
2536 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2537
2538 __GLX_SWAP_INT(pc + 0);
2539 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);
2540
2541 }
2542
2543 void
__glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc)2544 __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc)
2545 {
2546 __GLX_DECLARE_SWAP_VARIABLES;
2547 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2548
2549 __GLX_SWAP_INT(pc + 0);
2550 __GLX_SWAP_INT_ARRAY(pc + 4, 2);
2551
2552 }
2553
2554 void
__glXDispSwap_MultiTexCoord2svARB(GLbyte * pc)2555 __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc)
2556 {
2557 __GLX_DECLARE_SWAP_VARIABLES;
2558 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2559
2560 __GLX_SWAP_INT(pc + 0);
2561 __GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
2562
2563 }
2564
2565 void
__glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc)2566 __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc)
2567 {
2568 __GLX_DECLARE_SWAP_VARIABLES;
2569 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2570
2571 #ifdef __GLX_ALIGN64
2572 if ((unsigned long) (pc) & 7) {
2573 __GLX_MEM_COPY(pc - 4, pc, 28);
2574 pc -= 4;
2575 }
2576 #endif
2577 __GLX_SWAP_INT(pc + 24);
2578 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
2579
2580 }
2581
2582 void
__glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)2583 __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
2584 {
2585 __GLX_DECLARE_SWAP_VARIABLES;
2586 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2587
2588 __GLX_SWAP_INT(pc + 0);
2589 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);
2590
2591 }
2592
2593 void
__glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc)2594 __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc)
2595 {
2596 __GLX_DECLARE_SWAP_VARIABLES;
2597 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2598
2599 __GLX_SWAP_INT(pc + 0);
2600 __GLX_SWAP_INT_ARRAY(pc + 4, 3);
2601
2602 }
2603
2604 void
__glXDispSwap_MultiTexCoord3svARB(GLbyte * pc)2605 __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc)
2606 {
2607 __GLX_DECLARE_SWAP_VARIABLES;
2608 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2609
2610 __GLX_SWAP_INT(pc + 0);
2611 __GLX_SWAP_SHORT_ARRAY(pc + 4, 3);
2612
2613 }
2614
2615 void
__glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc)2616 __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc)
2617 {
2618 __GLX_DECLARE_SWAP_VARIABLES;
2619 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2620
2621 #ifdef __GLX_ALIGN64
2622 if ((unsigned long) (pc) & 7) {
2623 __GLX_MEM_COPY(pc - 4, pc, 36);
2624 pc -= 4;
2625 }
2626 #endif
2627 __GLX_SWAP_INT(pc + 32);
2628 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
2629
2630 }
2631
2632 void
__glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)2633 __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
2634 {
2635 __GLX_DECLARE_SWAP_VARIABLES;
2636 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2637
2638 __GLX_SWAP_INT(pc + 0);
2639 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);
2640
2641 }
2642
2643 void
__glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc)2644 __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc)
2645 {
2646 __GLX_DECLARE_SWAP_VARIABLES;
2647 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2648
2649 __GLX_SWAP_INT(pc + 0);
2650 __GLX_SWAP_INT_ARRAY(pc + 4, 4);
2651
2652 }
2653
2654 void
__glXDispSwap_MultiTexCoord4svARB(GLbyte * pc)2655 __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc)
2656 {
2657 __GLX_DECLARE_SWAP_VARIABLES;
2658 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2659
2660 __GLX_SWAP_INT(pc + 0);
2661 __GLX_SWAP_SHORT_ARRAY(pc + 4, 4);
2662
2663 }
2664