repositories / deb_xorg-server.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Upstream version 1.15.1
[deb_xorg-server.git] / hw / dmx / glxProxy / g_renderswap.c
CommitLineData
a09e091a
JB		 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
37void
38__glXDispSwap_CallList(GLbyte * pc)
39{
40 __GLX_DECLARE_SWAP_VARIABLES;
41
42 __GLX_SWAP_INT(pc + 0);
43
44}
45
46void
47__glXDispSwap_ListBase(GLbyte * pc)
48{
49 __GLX_DECLARE_SWAP_VARIABLES;
50
51 __GLX_SWAP_INT(pc + 0);
52
53}
54
55void
56__glXDispSwap_Begin(GLbyte * pc)
57{
58 __GLX_DECLARE_SWAP_VARIABLES;
59
60 __GLX_SWAP_INT(pc + 0);
61
62}
63
64void
65__glXDispSwap_Color3bv(GLbyte * pc)
66{
67}
68
69void
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
85void
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
94void
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
104void
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
114void
115__glXDispSwap_Color3ubv(GLbyte * pc)
116{
117}
118
119void
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
128void
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
137void
138__glXDispSwap_Color4bv(GLbyte * pc)
139{
140}
141
142void
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
157void
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
167void
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
177void
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
187void
188__glXDispSwap_Color4ubv(GLbyte * pc)
189{
190
191}
192
193void
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
203void
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
213void
214__glXDispSwap_EdgeFlagv(GLbyte * pc)
215{
216}
217
218void
219__glXDispSwap_End(GLbyte * pc)
220{
221}
222
223void
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
239void
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
249void
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
259void
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
269void
270__glXDispSwap_Normal3bv(GLbyte * pc)
271{
272}
273
274void
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
290void
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
300void
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
310void
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
320void
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
336void
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
346void
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
356void
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
366void
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
382void
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
392void
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
402void
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
412void
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
428void
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
438void
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
448void
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
458void
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
475void
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
486void
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
497void
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
508void
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
524void
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
534void
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
544void
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
554void
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
570void
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
580void
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
590void
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
600void
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
616void
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
626void
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
636void
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
646void
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
662void
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
672void
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
682void
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
692void
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
708void
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
718void
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
728void
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
738void
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
754void
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
764void
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
774void
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
784void
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
800void
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
810void
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
820void
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
830void
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
847void
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
857void
858__glXDispSwap_CullFace(GLbyte * pc)
859{
860 __GLX_DECLARE_SWAP_VARIABLES;
861
862 __GLX_SWAP_INT(pc + 0);
863
864}
865
866void
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
876void
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
894void
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
904void
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
922void
923__glXDispSwap_FrontFace(GLbyte * pc)
924{
925 __GLX_DECLARE_SWAP_VARIABLES;
926
927 __GLX_SWAP_INT(pc + 0);
928
929}
930
931void
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
941void
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
952void
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
971void
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
982void
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
1001void
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
1011void
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
1029void
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
1039void
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
1057void
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
1067void
1068__glXDispSwap_LineWidth(GLbyte * pc)
1069{
1070 __GLX_DECLARE_SWAP_VARIABLES;
1071
1072 __GLX_SWAP_FLOAT(pc + 0);
1073
1074}
1075
1076void
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
1087void
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
1106void
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
1117void
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
1136void
1137__glXDispSwap_PointSize(GLbyte * pc)
1138{
1139 __GLX_DECLARE_SWAP_VARIABLES;
1140
1141 __GLX_SWAP_FLOAT(pc + 0);
1142
1143}
1144
1145void
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
1155void
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
1167void
1168__glXDispSwap_ShadeModel(GLbyte * pc)
1169{
1170 __GLX_DECLARE_SWAP_VARIABLES;
1171
1172 __GLX_SWAP_INT(pc + 0);
1173
1174}
1175
1176void
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
1187void
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
1206void
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
1217void
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
1236void
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
1247void
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
1266void
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
1277void
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
1296void
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
1313void
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
1341void
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
1352void
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
1371void
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
1382void
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
1401void
1402__glXDispSwap_InitNames(GLbyte * pc)
1403{
1404}
1405
1406void
1407__glXDispSwap_LoadName(GLbyte * pc)
1408{
1409 __GLX_DECLARE_SWAP_VARIABLES;
1410
1411 __GLX_SWAP_INT(pc + 0);
1412
1413}
1414
1415void
1416__glXDispSwap_PassThrough(GLbyte * pc)
1417{
1418 __GLX_DECLARE_SWAP_VARIABLES;
1419
1420 __GLX_SWAP_FLOAT(pc + 0);
1421
1422}
1423
1424void
1425__glXDispSwap_PopName(GLbyte * pc)
1426{
1427}
1428
1429void
1430__glXDispSwap_PushName(GLbyte * pc)
1431{
1432 __GLX_DECLARE_SWAP_VARIABLES;
1433
1434 __GLX_SWAP_INT(pc + 0);
1435
1436}
1437
1438void
1439__glXDispSwap_DrawBuffer(GLbyte * pc)
1440{
1441 __GLX_DECLARE_SWAP_VARIABLES;
1442
1443 __GLX_SWAP_INT(pc + 0);
1444
1445}
1446
1447void
1448__glXDispSwap_Clear(GLbyte * pc)
1449{
1450 __GLX_DECLARE_SWAP_VARIABLES;
1451
1452 __GLX_SWAP_INT(pc + 0);
1453
1454}
1455
1456void
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
1468void
1469__glXDispSwap_ClearIndex(GLbyte * pc)
1470{
1471 __GLX_DECLARE_SWAP_VARIABLES;
1472
1473 __GLX_SWAP_FLOAT(pc + 0);
1474
1475}
1476
1477void
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
1489void
1490__glXDispSwap_ClearStencil(GLbyte * pc)
1491{
1492 __GLX_DECLARE_SWAP_VARIABLES;
1493
1494 __GLX_SWAP_INT(pc + 0);
1495
1496}
1497
1498void
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
1513void
1514__glXDispSwap_StencilMask(GLbyte * pc)
1515{
1516 __GLX_DECLARE_SWAP_VARIABLES;
1517
1518 __GLX_SWAP_INT(pc + 0);
1519
1520}
1521
1522void
1523__glXDispSwap_ColorMask(GLbyte * pc)
1524{
1525}
1526
1527void
1528__glXDispSwap_DepthMask(GLbyte * pc)
1529{
1530}
1531
1532void
1533__glXDispSwap_IndexMask(GLbyte * pc)
1534{
1535 __GLX_DECLARE_SWAP_VARIABLES;
1536
1537 __GLX_SWAP_INT(pc + 0);
1538
1539}
1540
1541void
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
1551void
1552__glXDispSwap_Disable(GLbyte * pc)
1553{
1554 __GLX_DECLARE_SWAP_VARIABLES;
1555
1556 __GLX_SWAP_INT(pc + 0);
1557
1558}
1559
1560void
1561__glXDispSwap_Enable(GLbyte * pc)
1562{
1563 __GLX_DECLARE_SWAP_VARIABLES;
1564
1565 __GLX_SWAP_INT(pc + 0);
1566
1567}
1568
1569void
1570__glXDispSwap_PopAttrib(GLbyte * pc)
1571{
1572}
1573
1574void
1575__glXDispSwap_PushAttrib(GLbyte * pc)
1576{
1577 __GLX_DECLARE_SWAP_VARIABLES;
1578
1579 __GLX_SWAP_INT(pc + 0);
1580
1581}
1582
1583void
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
1600void
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
1611void
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
1631void
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
1645void
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
1661void
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
1671void
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
1687void
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
1697void
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
1708void
1709__glXDispSwap_EvalPoint1(GLbyte * pc)
1710{
1711 __GLX_DECLARE_SWAP_VARIABLES;
1712
1713 __GLX_SWAP_INT(pc + 0);
1714
1715}
1716
1717void
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
1730void
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
1740void
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
1750void
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
1760void
1761__glXDispSwap_LogicOp(GLbyte * pc)
1762{
1763 __GLX_DECLARE_SWAP_VARIABLES;
1764
1765 __GLX_SWAP_INT(pc + 0);
1766
1767}
1768
1769void
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
1780void
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
1791void
1792__glXDispSwap_DepthFunc(GLbyte * pc)
1793{
1794 __GLX_DECLARE_SWAP_VARIABLES;
1795
1796 __GLX_SWAP_INT(pc + 0);
1797
1798}
1799
1800void
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
1810void
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
1820void
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
1830void
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
1845void
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
1860void
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
1875void
1876__glXDispSwap_ReadBuffer(GLbyte * pc)
1877{
1878 __GLX_DECLARE_SWAP_VARIABLES;
1879
1880 __GLX_SWAP_INT(pc + 0);
1881
1882}
1883
1884void
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
1897void
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
1913void
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
1933void
1934__glXDispSwap_LoadIdentity(GLbyte * pc)
1935{
1936}
1937
1938void
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
1948void
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
1964void
1965__glXDispSwap_MatrixMode(GLbyte * pc)
1966{
1967 __GLX_DECLARE_SWAP_VARIABLES;
1968
1969 __GLX_SWAP_INT(pc + 0);
1970
1971}
1972
1973void
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
1983void
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
1999void
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
2019void
2020__glXDispSwap_PopMatrix(GLbyte * pc)
2021{
2022}
2023
2024void
2025__glXDispSwap_PushMatrix(GLbyte * pc)
2026{
2027}
2028
2029void
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
2047void
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
2059void
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
2076void
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
2087void
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
2104void
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
2115void
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
2127void
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
2137void
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
2152void
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
2168void
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
2182void
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
2198void
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
2208void
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
2223void
2224__glXDispSwap_Indexubv(GLbyte * pc)
2225{
2226}
2227
2228void
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
2240void
2241__glXDispSwap_BlendEquation(GLbyte * pc)
2242{
2243 __GLX_DECLARE_SWAP_VARIABLES;
2244
2245 __GLX_SWAP_INT(pc + 0);
2246
2247}
2248
2249void
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
2268void
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
2287void
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
2300void
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
2313void
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
2324void
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
2343void
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
2354void
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
2373void
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
2386void
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
2400void
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
2411void
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
2421void
2422__glXDispSwap_ResetHistogram(GLbyte * pc)
2423{
2424 __GLX_DECLARE_SWAP_VARIABLES;
2425
2426 __GLX_SWAP_INT(pc + 0);
2427
2428}
2429
2430void
2431__glXDispSwap_ResetMinmax(GLbyte * pc)
2432{
2433 __GLX_DECLARE_SWAP_VARIABLES;
2434
2435 __GLX_SWAP_INT(pc + 0);
2436
2437}
2438
2439void
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
2456void
2457__glXDispSwap_ActiveTextureARB(GLbyte * pc)
2458{
2459 __GLX_DECLARE_SWAP_VARIABLES;
2460
2461 __GLX_SWAP_INT(pc + 0);
2462
2463}
2464
2465void
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
2482void
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
2493void
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
2504void
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
2515void
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
2532void
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
2543void
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
2554void
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
2565void
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
2582void
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
2593void
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
2604void
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
2615void
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
2632void
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
2643void
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
2654void
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}
xorg-server Piment Noir Debian package repository