1 /* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
2
3 /*
4 * (C) Copyright IBM Corporation 2005
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sub license,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * IBM,
22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
26 */
27
28 #include <inttypes.h>
29 #include "glxserver.h"
30 #include "indirect_size.h"
31 #include "indirect_size_get.h"
32 #include "indirect_dispatch.h"
33 #include "glxbyteorder.h"
34 #include "indirect_util.h"
35 #include "singlesize.h"
36
37 #define __GLX_PAD(x) (((x) + 3) & ~3)
38
39 typedef struct {
40 __GLX_PIXEL_3D_HDR;
41 } __GLXpixel3DHeader;
42
43 extern GLboolean __glXErrorOccured(void);
44 extern void __glXClearErrorOccured(void);
45
46 static const unsigned dummy_answer[2] = { 0, 0 };
47
48 static GLsizei
bswap_CARD32(const void * src)49 bswap_CARD32(const void *src)
50 {
51 union {
52 uint32_t dst;
53 GLsizei ret;
54 } x;
55
56 x.dst = bswap_32(*(uint32_t *) src);
57 return x.ret;
58 }
59
60 static GLshort
bswap_CARD16(const void * src)61 bswap_CARD16(const void *src)
62 {
63 union {
64 uint16_t dst;
65 GLshort ret;
66 } x;
67
68 x.dst = bswap_16(*(uint16_t *) src);
69 return x.ret;
70 }
71
72 static GLenum
bswap_ENUM(const void * src)73 bswap_ENUM(const void *src)
74 {
75 union {
76 uint32_t dst;
77 GLenum ret;
78 } x;
79
80 x.dst = bswap_32(*(uint32_t *) src);
81 return x.ret;
82 }
83
84 static GLsync
bswap_CARD64(const void * src)85 bswap_CARD64(const void *src)
86 {
87 union {
88 uint64_t dst;
89 GLsync ret;
90 } x;
91
92 x.dst = bswap_64(*(uint64_t *) src);
93 return x.ret;
94 }
95
96 static GLdouble
bswap_FLOAT64(const void * src)97 bswap_FLOAT64(const void *src)
98 {
99 union {
100 uint64_t dst;
101 GLdouble ret;
102 } x;
103
104 x.dst = bswap_64(*(uint64_t *) src);
105 return x.ret;
106 }
107
108 static GLfloat
bswap_FLOAT32(const void * src)109 bswap_FLOAT32(const void *src)
110 {
111 union {
112 uint32_t dst;
113 GLfloat ret;
114 } x;
115
116 x.dst = bswap_32(*(uint32_t *) src);
117 return x.ret;
118 }
119
120 static void *
bswap_16_array(uint16_t * src,unsigned count)121 bswap_16_array(uint16_t * src, unsigned count)
122 {
123 unsigned i;
124
125 for (i = 0; i < count; i++) {
126 uint16_t temp = bswap_16(src[i]);
127
128 src[i] = temp;
129 }
130
131 return src;
132 }
133
134 static void *
bswap_32_array(uint32_t * src,unsigned count)135 bswap_32_array(uint32_t * src, unsigned count)
136 {
137 unsigned i;
138
139 for (i = 0; i < count; i++) {
140 uint32_t temp = bswap_32(src[i]);
141
142 src[i] = temp;
143 }
144
145 return src;
146 }
147
148 static void *
bswap_64_array(uint64_t * src,unsigned count)149 bswap_64_array(uint64_t * src, unsigned count)
150 {
151 unsigned i;
152
153 for (i = 0; i < count; i++) {
154 uint64_t temp = bswap_64(src[i]);
155
156 src[i] = temp;
157 }
158
159 return src;
160 }
161
162 int
__glXDispSwap_NewList(__GLXclientState * cl,GLbyte * pc)163 __glXDispSwap_NewList(__GLXclientState * cl, GLbyte * pc)
164 {
165 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
166 int error;
167 __GLXcontext *const cx =
168 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
169
170 pc += __GLX_SINGLE_HDR_SIZE;
171 if (cx != NULL) {
172 glNewList((GLuint) bswap_CARD32(pc + 0), (GLenum) bswap_ENUM(pc + 4));
173 error = Success;
174 }
175
176 return error;
177 }
178
179 int
__glXDispSwap_EndList(__GLXclientState * cl,GLbyte * pc)180 __glXDispSwap_EndList(__GLXclientState * cl, GLbyte * pc)
181 {
182 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
183 int error;
184 __GLXcontext *const cx =
185 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
186
187 pc += __GLX_SINGLE_HDR_SIZE;
188 if (cx != NULL) {
189 glEndList();
190 error = Success;
191 }
192
193 return error;
194 }
195
196 void
__glXDispSwap_CallList(GLbyte * pc)197 __glXDispSwap_CallList(GLbyte * pc)
198 {
199 glCallList((GLuint) bswap_CARD32(pc + 0));
200 }
201
202 void
__glXDispSwap_CallLists(GLbyte * pc)203 __glXDispSwap_CallLists(GLbyte * pc)
204 {
205 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
206 const GLenum type = (GLenum) bswap_ENUM(pc + 4);
207 const GLvoid *lists;
208
209 switch (type) {
210 case GL_BYTE:
211 case GL_UNSIGNED_BYTE:
212 case GL_2_BYTES:
213 case GL_3_BYTES:
214 case GL_4_BYTES:
215 lists = (const GLvoid *) (pc + 8);
216 break;
217 case GL_SHORT:
218 case GL_UNSIGNED_SHORT:
219 lists = (const GLvoid *) bswap_16_array((uint16_t *) (pc + 8), n);
220 break;
221 case GL_INT:
222 case GL_UNSIGNED_INT:
223 case GL_FLOAT:
224 lists = (const GLvoid *) bswap_32_array((uint32_t *) (pc + 8), n);
225 break;
226 default:
227 return;
228 }
229
230 glCallLists(n, type, lists);
231 }
232
233 int
__glXDispSwap_DeleteLists(__GLXclientState * cl,GLbyte * pc)234 __glXDispSwap_DeleteLists(__GLXclientState * cl, GLbyte * pc)
235 {
236 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
237 int error;
238 __GLXcontext *const cx =
239 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
240
241 pc += __GLX_SINGLE_HDR_SIZE;
242 if (cx != NULL) {
243 glDeleteLists((GLuint) bswap_CARD32(pc + 0),
244 (GLsizei) bswap_CARD32(pc + 4));
245 error = Success;
246 }
247
248 return error;
249 }
250
251 int
__glXDispSwap_GenLists(__GLXclientState * cl,GLbyte * pc)252 __glXDispSwap_GenLists(__GLXclientState * cl, GLbyte * pc)
253 {
254 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
255 int error;
256 __GLXcontext *const cx =
257 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
258
259 pc += __GLX_SINGLE_HDR_SIZE;
260 if (cx != NULL) {
261 GLuint retval;
262
263 retval = glGenLists((GLsizei) bswap_CARD32(pc + 0));
264 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
265 error = Success;
266 }
267
268 return error;
269 }
270
271 void
__glXDispSwap_ListBase(GLbyte * pc)272 __glXDispSwap_ListBase(GLbyte * pc)
273 {
274 glListBase((GLuint) bswap_CARD32(pc + 0));
275 }
276
277 void
__glXDispSwap_Begin(GLbyte * pc)278 __glXDispSwap_Begin(GLbyte * pc)
279 {
280 glBegin((GLenum) bswap_ENUM(pc + 0));
281 }
282
283 void
__glXDispSwap_Bitmap(GLbyte * pc)284 __glXDispSwap_Bitmap(GLbyte * pc)
285 {
286 const GLubyte *const bitmap = (const GLubyte *) ((pc + 44));
287 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
288
289 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
290 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
291 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
292 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
293 (GLint) bswap_CARD32(&hdr->skipPixels));
294 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
295
296 glBitmap((GLsizei) bswap_CARD32(pc + 20),
297 (GLsizei) bswap_CARD32(pc + 24),
298 (GLfloat) bswap_FLOAT32(pc + 28),
299 (GLfloat) bswap_FLOAT32(pc + 32),
300 (GLfloat) bswap_FLOAT32(pc + 36),
301 (GLfloat) bswap_FLOAT32(pc + 40), bitmap);
302 }
303
304 void
__glXDispSwap_Color3bv(GLbyte * pc)305 __glXDispSwap_Color3bv(GLbyte * pc)
306 {
307 glColor3bv((const GLbyte *) (pc + 0));
308 }
309
310 void
__glXDispSwap_Color3dv(GLbyte * pc)311 __glXDispSwap_Color3dv(GLbyte * pc)
312 {
313 #ifdef __GLX_ALIGN64
314 if ((unsigned long) (pc) & 7) {
315 (void) memmove(pc - 4, pc, 24);
316 pc -= 4;
317 }
318 #endif
319
320 glColor3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
321 }
322
323 void
__glXDispSwap_Color3fv(GLbyte * pc)324 __glXDispSwap_Color3fv(GLbyte * pc)
325 {
326 glColor3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
327 }
328
329 void
__glXDispSwap_Color3iv(GLbyte * pc)330 __glXDispSwap_Color3iv(GLbyte * pc)
331 {
332 glColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
333 }
334
335 void
__glXDispSwap_Color3sv(GLbyte * pc)336 __glXDispSwap_Color3sv(GLbyte * pc)
337 {
338 glColor3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
339 }
340
341 void
__glXDispSwap_Color3ubv(GLbyte * pc)342 __glXDispSwap_Color3ubv(GLbyte * pc)
343 {
344 glColor3ubv((const GLubyte *) (pc + 0));
345 }
346
347 void
__glXDispSwap_Color3uiv(GLbyte * pc)348 __glXDispSwap_Color3uiv(GLbyte * pc)
349 {
350 glColor3uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 3));
351 }
352
353 void
__glXDispSwap_Color3usv(GLbyte * pc)354 __glXDispSwap_Color3usv(GLbyte * pc)
355 {
356 glColor3usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 3));
357 }
358
359 void
__glXDispSwap_Color4bv(GLbyte * pc)360 __glXDispSwap_Color4bv(GLbyte * pc)
361 {
362 glColor4bv((const GLbyte *) (pc + 0));
363 }
364
365 void
__glXDispSwap_Color4dv(GLbyte * pc)366 __glXDispSwap_Color4dv(GLbyte * pc)
367 {
368 #ifdef __GLX_ALIGN64
369 if ((unsigned long) (pc) & 7) {
370 (void) memmove(pc - 4, pc, 32);
371 pc -= 4;
372 }
373 #endif
374
375 glColor4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
376 }
377
378 void
__glXDispSwap_Color4fv(GLbyte * pc)379 __glXDispSwap_Color4fv(GLbyte * pc)
380 {
381 glColor4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
382 }
383
384 void
__glXDispSwap_Color4iv(GLbyte * pc)385 __glXDispSwap_Color4iv(GLbyte * pc)
386 {
387 glColor4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
388 }
389
390 void
__glXDispSwap_Color4sv(GLbyte * pc)391 __glXDispSwap_Color4sv(GLbyte * pc)
392 {
393 glColor4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
394 }
395
396 void
__glXDispSwap_Color4ubv(GLbyte * pc)397 __glXDispSwap_Color4ubv(GLbyte * pc)
398 {
399 glColor4ubv((const GLubyte *) (pc + 0));
400 }
401
402 void
__glXDispSwap_Color4uiv(GLbyte * pc)403 __glXDispSwap_Color4uiv(GLbyte * pc)
404 {
405 glColor4uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 4));
406 }
407
408 void
__glXDispSwap_Color4usv(GLbyte * pc)409 __glXDispSwap_Color4usv(GLbyte * pc)
410 {
411 glColor4usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 4));
412 }
413
414 void
__glXDispSwap_EdgeFlagv(GLbyte * pc)415 __glXDispSwap_EdgeFlagv(GLbyte * pc)
416 {
417 glEdgeFlagv((const GLboolean *) (pc + 0));
418 }
419
420 void
__glXDispSwap_End(GLbyte * pc)421 __glXDispSwap_End(GLbyte * pc)
422 {
423 glEnd();
424 }
425
426 void
__glXDispSwap_Indexdv(GLbyte * pc)427 __glXDispSwap_Indexdv(GLbyte * pc)
428 {
429 #ifdef __GLX_ALIGN64
430 if ((unsigned long) (pc) & 7) {
431 (void) memmove(pc - 4, pc, 8);
432 pc -= 4;
433 }
434 #endif
435
436 glIndexdv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
437 }
438
439 void
__glXDispSwap_Indexfv(GLbyte * pc)440 __glXDispSwap_Indexfv(GLbyte * pc)
441 {
442 glIndexfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
443 }
444
445 void
__glXDispSwap_Indexiv(GLbyte * pc)446 __glXDispSwap_Indexiv(GLbyte * pc)
447 {
448 glIndexiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1));
449 }
450
451 void
__glXDispSwap_Indexsv(GLbyte * pc)452 __glXDispSwap_Indexsv(GLbyte * pc)
453 {
454 glIndexsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1));
455 }
456
457 void
__glXDispSwap_Normal3bv(GLbyte * pc)458 __glXDispSwap_Normal3bv(GLbyte * pc)
459 {
460 glNormal3bv((const GLbyte *) (pc + 0));
461 }
462
463 void
__glXDispSwap_Normal3dv(GLbyte * pc)464 __glXDispSwap_Normal3dv(GLbyte * pc)
465 {
466 #ifdef __GLX_ALIGN64
467 if ((unsigned long) (pc) & 7) {
468 (void) memmove(pc - 4, pc, 24);
469 pc -= 4;
470 }
471 #endif
472
473 glNormal3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
474 }
475
476 void
__glXDispSwap_Normal3fv(GLbyte * pc)477 __glXDispSwap_Normal3fv(GLbyte * pc)
478 {
479 glNormal3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
480 }
481
482 void
__glXDispSwap_Normal3iv(GLbyte * pc)483 __glXDispSwap_Normal3iv(GLbyte * pc)
484 {
485 glNormal3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
486 }
487
488 void
__glXDispSwap_Normal3sv(GLbyte * pc)489 __glXDispSwap_Normal3sv(GLbyte * pc)
490 {
491 glNormal3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
492 }
493
494 void
__glXDispSwap_RasterPos2dv(GLbyte * pc)495 __glXDispSwap_RasterPos2dv(GLbyte * pc)
496 {
497 #ifdef __GLX_ALIGN64
498 if ((unsigned long) (pc) & 7) {
499 (void) memmove(pc - 4, pc, 16);
500 pc -= 4;
501 }
502 #endif
503
504 glRasterPos2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
505 }
506
507 void
__glXDispSwap_RasterPos2fv(GLbyte * pc)508 __glXDispSwap_RasterPos2fv(GLbyte * pc)
509 {
510 glRasterPos2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
511 }
512
513 void
__glXDispSwap_RasterPos2iv(GLbyte * pc)514 __glXDispSwap_RasterPos2iv(GLbyte * pc)
515 {
516 glRasterPos2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
517 }
518
519 void
__glXDispSwap_RasterPos2sv(GLbyte * pc)520 __glXDispSwap_RasterPos2sv(GLbyte * pc)
521 {
522 glRasterPos2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
523 }
524
525 void
__glXDispSwap_RasterPos3dv(GLbyte * pc)526 __glXDispSwap_RasterPos3dv(GLbyte * pc)
527 {
528 #ifdef __GLX_ALIGN64
529 if ((unsigned long) (pc) & 7) {
530 (void) memmove(pc - 4, pc, 24);
531 pc -= 4;
532 }
533 #endif
534
535 glRasterPos3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
536 }
537
538 void
__glXDispSwap_RasterPos3fv(GLbyte * pc)539 __glXDispSwap_RasterPos3fv(GLbyte * pc)
540 {
541 glRasterPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
542 }
543
544 void
__glXDispSwap_RasterPos3iv(GLbyte * pc)545 __glXDispSwap_RasterPos3iv(GLbyte * pc)
546 {
547 glRasterPos3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
548 }
549
550 void
__glXDispSwap_RasterPos3sv(GLbyte * pc)551 __glXDispSwap_RasterPos3sv(GLbyte * pc)
552 {
553 glRasterPos3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
554 }
555
556 void
__glXDispSwap_RasterPos4dv(GLbyte * pc)557 __glXDispSwap_RasterPos4dv(GLbyte * pc)
558 {
559 #ifdef __GLX_ALIGN64
560 if ((unsigned long) (pc) & 7) {
561 (void) memmove(pc - 4, pc, 32);
562 pc -= 4;
563 }
564 #endif
565
566 glRasterPos4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
567 }
568
569 void
__glXDispSwap_RasterPos4fv(GLbyte * pc)570 __glXDispSwap_RasterPos4fv(GLbyte * pc)
571 {
572 glRasterPos4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
573 }
574
575 void
__glXDispSwap_RasterPos4iv(GLbyte * pc)576 __glXDispSwap_RasterPos4iv(GLbyte * pc)
577 {
578 glRasterPos4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
579 }
580
581 void
__glXDispSwap_RasterPos4sv(GLbyte * pc)582 __glXDispSwap_RasterPos4sv(GLbyte * pc)
583 {
584 glRasterPos4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
585 }
586
587 void
__glXDispSwap_Rectdv(GLbyte * pc)588 __glXDispSwap_Rectdv(GLbyte * pc)
589 {
590 #ifdef __GLX_ALIGN64
591 if ((unsigned long) (pc) & 7) {
592 (void) memmove(pc - 4, pc, 32);
593 pc -= 4;
594 }
595 #endif
596
597 glRectdv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2),
598 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 16), 2));
599 }
600
601 void
__glXDispSwap_Rectfv(GLbyte * pc)602 __glXDispSwap_Rectfv(GLbyte * pc)
603 {
604 glRectfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2),
605 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), 2));
606 }
607
608 void
__glXDispSwap_Rectiv(GLbyte * pc)609 __glXDispSwap_Rectiv(GLbyte * pc)
610 {
611 glRectiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2),
612 (const GLint *) bswap_32_array((uint32_t *) (pc + 8), 2));
613 }
614
615 void
__glXDispSwap_Rectsv(GLbyte * pc)616 __glXDispSwap_Rectsv(GLbyte * pc)
617 {
618 glRectsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2),
619 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2));
620 }
621
622 void
__glXDispSwap_TexCoord1dv(GLbyte * pc)623 __glXDispSwap_TexCoord1dv(GLbyte * pc)
624 {
625 #ifdef __GLX_ALIGN64
626 if ((unsigned long) (pc) & 7) {
627 (void) memmove(pc - 4, pc, 8);
628 pc -= 4;
629 }
630 #endif
631
632 glTexCoord1dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
633 }
634
635 void
__glXDispSwap_TexCoord1fv(GLbyte * pc)636 __glXDispSwap_TexCoord1fv(GLbyte * pc)
637 {
638 glTexCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
639 }
640
641 void
__glXDispSwap_TexCoord1iv(GLbyte * pc)642 __glXDispSwap_TexCoord1iv(GLbyte * pc)
643 {
644 glTexCoord1iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1));
645 }
646
647 void
__glXDispSwap_TexCoord1sv(GLbyte * pc)648 __glXDispSwap_TexCoord1sv(GLbyte * pc)
649 {
650 glTexCoord1sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1));
651 }
652
653 void
__glXDispSwap_TexCoord2dv(GLbyte * pc)654 __glXDispSwap_TexCoord2dv(GLbyte * pc)
655 {
656 #ifdef __GLX_ALIGN64
657 if ((unsigned long) (pc) & 7) {
658 (void) memmove(pc - 4, pc, 16);
659 pc -= 4;
660 }
661 #endif
662
663 glTexCoord2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
664 }
665
666 void
__glXDispSwap_TexCoord2fv(GLbyte * pc)667 __glXDispSwap_TexCoord2fv(GLbyte * pc)
668 {
669 glTexCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
670 }
671
672 void
__glXDispSwap_TexCoord2iv(GLbyte * pc)673 __glXDispSwap_TexCoord2iv(GLbyte * pc)
674 {
675 glTexCoord2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
676 }
677
678 void
__glXDispSwap_TexCoord2sv(GLbyte * pc)679 __glXDispSwap_TexCoord2sv(GLbyte * pc)
680 {
681 glTexCoord2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
682 }
683
684 void
__glXDispSwap_TexCoord3dv(GLbyte * pc)685 __glXDispSwap_TexCoord3dv(GLbyte * pc)
686 {
687 #ifdef __GLX_ALIGN64
688 if ((unsigned long) (pc) & 7) {
689 (void) memmove(pc - 4, pc, 24);
690 pc -= 4;
691 }
692 #endif
693
694 glTexCoord3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
695 }
696
697 void
__glXDispSwap_TexCoord3fv(GLbyte * pc)698 __glXDispSwap_TexCoord3fv(GLbyte * pc)
699 {
700 glTexCoord3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
701 }
702
703 void
__glXDispSwap_TexCoord3iv(GLbyte * pc)704 __glXDispSwap_TexCoord3iv(GLbyte * pc)
705 {
706 glTexCoord3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
707 }
708
709 void
__glXDispSwap_TexCoord3sv(GLbyte * pc)710 __glXDispSwap_TexCoord3sv(GLbyte * pc)
711 {
712 glTexCoord3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
713 }
714
715 void
__glXDispSwap_TexCoord4dv(GLbyte * pc)716 __glXDispSwap_TexCoord4dv(GLbyte * pc)
717 {
718 #ifdef __GLX_ALIGN64
719 if ((unsigned long) (pc) & 7) {
720 (void) memmove(pc - 4, pc, 32);
721 pc -= 4;
722 }
723 #endif
724
725 glTexCoord4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
726 }
727
728 void
__glXDispSwap_TexCoord4fv(GLbyte * pc)729 __glXDispSwap_TexCoord4fv(GLbyte * pc)
730 {
731 glTexCoord4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
732 }
733
734 void
__glXDispSwap_TexCoord4iv(GLbyte * pc)735 __glXDispSwap_TexCoord4iv(GLbyte * pc)
736 {
737 glTexCoord4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
738 }
739
740 void
__glXDispSwap_TexCoord4sv(GLbyte * pc)741 __glXDispSwap_TexCoord4sv(GLbyte * pc)
742 {
743 glTexCoord4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
744 }
745
746 void
__glXDispSwap_Vertex2dv(GLbyte * pc)747 __glXDispSwap_Vertex2dv(GLbyte * pc)
748 {
749 #ifdef __GLX_ALIGN64
750 if ((unsigned long) (pc) & 7) {
751 (void) memmove(pc - 4, pc, 16);
752 pc -= 4;
753 }
754 #endif
755
756 glVertex2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
757 }
758
759 void
__glXDispSwap_Vertex2fv(GLbyte * pc)760 __glXDispSwap_Vertex2fv(GLbyte * pc)
761 {
762 glVertex2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
763 }
764
765 void
__glXDispSwap_Vertex2iv(GLbyte * pc)766 __glXDispSwap_Vertex2iv(GLbyte * pc)
767 {
768 glVertex2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
769 }
770
771 void
__glXDispSwap_Vertex2sv(GLbyte * pc)772 __glXDispSwap_Vertex2sv(GLbyte * pc)
773 {
774 glVertex2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
775 }
776
777 void
__glXDispSwap_Vertex3dv(GLbyte * pc)778 __glXDispSwap_Vertex3dv(GLbyte * pc)
779 {
780 #ifdef __GLX_ALIGN64
781 if ((unsigned long) (pc) & 7) {
782 (void) memmove(pc - 4, pc, 24);
783 pc -= 4;
784 }
785 #endif
786
787 glVertex3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
788 }
789
790 void
__glXDispSwap_Vertex3fv(GLbyte * pc)791 __glXDispSwap_Vertex3fv(GLbyte * pc)
792 {
793 glVertex3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
794 }
795
796 void
__glXDispSwap_Vertex3iv(GLbyte * pc)797 __glXDispSwap_Vertex3iv(GLbyte * pc)
798 {
799 glVertex3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
800 }
801
802 void
__glXDispSwap_Vertex3sv(GLbyte * pc)803 __glXDispSwap_Vertex3sv(GLbyte * pc)
804 {
805 glVertex3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
806 }
807
808 void
__glXDispSwap_Vertex4dv(GLbyte * pc)809 __glXDispSwap_Vertex4dv(GLbyte * pc)
810 {
811 #ifdef __GLX_ALIGN64
812 if ((unsigned long) (pc) & 7) {
813 (void) memmove(pc - 4, pc, 32);
814 pc -= 4;
815 }
816 #endif
817
818 glVertex4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
819 }
820
821 void
__glXDispSwap_Vertex4fv(GLbyte * pc)822 __glXDispSwap_Vertex4fv(GLbyte * pc)
823 {
824 glVertex4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
825 }
826
827 void
__glXDispSwap_Vertex4iv(GLbyte * pc)828 __glXDispSwap_Vertex4iv(GLbyte * pc)
829 {
830 glVertex4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
831 }
832
833 void
__glXDispSwap_Vertex4sv(GLbyte * pc)834 __glXDispSwap_Vertex4sv(GLbyte * pc)
835 {
836 glVertex4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
837 }
838
839 void
__glXDispSwap_ClipPlane(GLbyte * pc)840 __glXDispSwap_ClipPlane(GLbyte * pc)
841 {
842 #ifdef __GLX_ALIGN64
843 if ((unsigned long) (pc) & 7) {
844 (void) memmove(pc - 4, pc, 36);
845 pc -= 4;
846 }
847 #endif
848
849 glClipPlane((GLenum) bswap_ENUM(pc + 32),
850 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
851 }
852
853 void
__glXDispSwap_ColorMaterial(GLbyte * pc)854 __glXDispSwap_ColorMaterial(GLbyte * pc)
855 {
856 glColorMaterial((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
857 }
858
859 void
__glXDispSwap_CullFace(GLbyte * pc)860 __glXDispSwap_CullFace(GLbyte * pc)
861 {
862 glCullFace((GLenum) bswap_ENUM(pc + 0));
863 }
864
865 void
__glXDispSwap_Fogf(GLbyte * pc)866 __glXDispSwap_Fogf(GLbyte * pc)
867 {
868 glFogf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
869 }
870
871 void
__glXDispSwap_Fogfv(GLbyte * pc)872 __glXDispSwap_Fogfv(GLbyte * pc)
873 {
874 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
875 const GLfloat *params;
876
877 params =
878 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
879 __glFogfv_size(pname));
880
881 glFogfv(pname, params);
882 }
883
884 void
__glXDispSwap_Fogi(GLbyte * pc)885 __glXDispSwap_Fogi(GLbyte * pc)
886 {
887 glFogi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
888 }
889
890 void
__glXDispSwap_Fogiv(GLbyte * pc)891 __glXDispSwap_Fogiv(GLbyte * pc)
892 {
893 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
894 const GLint *params;
895
896 params =
897 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
898 __glFogiv_size(pname));
899
900 glFogiv(pname, params);
901 }
902
903 void
__glXDispSwap_FrontFace(GLbyte * pc)904 __glXDispSwap_FrontFace(GLbyte * pc)
905 {
906 glFrontFace((GLenum) bswap_ENUM(pc + 0));
907 }
908
909 void
__glXDispSwap_Hint(GLbyte * pc)910 __glXDispSwap_Hint(GLbyte * pc)
911 {
912 glHint((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
913 }
914
915 void
__glXDispSwap_Lightf(GLbyte * pc)916 __glXDispSwap_Lightf(GLbyte * pc)
917 {
918 glLightf((GLenum) bswap_ENUM(pc + 0),
919 (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
920 }
921
922 void
__glXDispSwap_Lightfv(GLbyte * pc)923 __glXDispSwap_Lightfv(GLbyte * pc)
924 {
925 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
926 const GLfloat *params;
927
928 params =
929 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
930 __glLightfv_size(pname));
931
932 glLightfv((GLenum) bswap_ENUM(pc + 0), pname, params);
933 }
934
935 void
__glXDispSwap_Lighti(GLbyte * pc)936 __glXDispSwap_Lighti(GLbyte * pc)
937 {
938 glLighti((GLenum) bswap_ENUM(pc + 0),
939 (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
940 }
941
942 void
__glXDispSwap_Lightiv(GLbyte * pc)943 __glXDispSwap_Lightiv(GLbyte * pc)
944 {
945 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
946 const GLint *params;
947
948 params =
949 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
950 __glLightiv_size(pname));
951
952 glLightiv((GLenum) bswap_ENUM(pc + 0), pname, params);
953 }
954
955 void
__glXDispSwap_LightModelf(GLbyte * pc)956 __glXDispSwap_LightModelf(GLbyte * pc)
957 {
958 glLightModelf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
959 }
960
961 void
__glXDispSwap_LightModelfv(GLbyte * pc)962 __glXDispSwap_LightModelfv(GLbyte * pc)
963 {
964 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
965 const GLfloat *params;
966
967 params =
968 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
969 __glLightModelfv_size(pname));
970
971 glLightModelfv(pname, params);
972 }
973
974 void
__glXDispSwap_LightModeli(GLbyte * pc)975 __glXDispSwap_LightModeli(GLbyte * pc)
976 {
977 glLightModeli((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
978 }
979
980 void
__glXDispSwap_LightModeliv(GLbyte * pc)981 __glXDispSwap_LightModeliv(GLbyte * pc)
982 {
983 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
984 const GLint *params;
985
986 params =
987 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
988 __glLightModeliv_size(pname));
989
990 glLightModeliv(pname, params);
991 }
992
993 void
__glXDispSwap_LineStipple(GLbyte * pc)994 __glXDispSwap_LineStipple(GLbyte * pc)
995 {
996 glLineStipple((GLint) bswap_CARD32(pc + 0),
997 (GLushort) bswap_CARD16(pc + 4));
998 }
999
1000 void
__glXDispSwap_LineWidth(GLbyte * pc)1001 __glXDispSwap_LineWidth(GLbyte * pc)
1002 {
1003 glLineWidth((GLfloat) bswap_FLOAT32(pc + 0));
1004 }
1005
1006 void
__glXDispSwap_Materialf(GLbyte * pc)1007 __glXDispSwap_Materialf(GLbyte * pc)
1008 {
1009 glMaterialf((GLenum) bswap_ENUM(pc + 0),
1010 (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
1011 }
1012
1013 void
__glXDispSwap_Materialfv(GLbyte * pc)1014 __glXDispSwap_Materialfv(GLbyte * pc)
1015 {
1016 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1017 const GLfloat *params;
1018
1019 params =
1020 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
1021 __glMaterialfv_size(pname));
1022
1023 glMaterialfv((GLenum) bswap_ENUM(pc + 0), pname, params);
1024 }
1025
1026 void
__glXDispSwap_Materiali(GLbyte * pc)1027 __glXDispSwap_Materiali(GLbyte * pc)
1028 {
1029 glMateriali((GLenum) bswap_ENUM(pc + 0),
1030 (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
1031 }
1032
1033 void
__glXDispSwap_Materialiv(GLbyte * pc)1034 __glXDispSwap_Materialiv(GLbyte * pc)
1035 {
1036 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1037 const GLint *params;
1038
1039 params =
1040 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
1041 __glMaterialiv_size(pname));
1042
1043 glMaterialiv((GLenum) bswap_ENUM(pc + 0), pname, params);
1044 }
1045
1046 void
__glXDispSwap_PointSize(GLbyte * pc)1047 __glXDispSwap_PointSize(GLbyte * pc)
1048 {
1049 glPointSize((GLfloat) bswap_FLOAT32(pc + 0));
1050 }
1051
1052 void
__glXDispSwap_PolygonMode(GLbyte * pc)1053 __glXDispSwap_PolygonMode(GLbyte * pc)
1054 {
1055 glPolygonMode((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
1056 }
1057
1058 void
__glXDispSwap_PolygonStipple(GLbyte * pc)1059 __glXDispSwap_PolygonStipple(GLbyte * pc)
1060 {
1061 const GLubyte *const mask = (const GLubyte *) ((pc + 20));
1062 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
1063
1064 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
1065 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
1066 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
1067 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
1068 (GLint) bswap_CARD32(&hdr->skipPixels));
1069 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
1070
1071 glPolygonStipple(mask);
1072 }
1073
1074 void
__glXDispSwap_Scissor(GLbyte * pc)1075 __glXDispSwap_Scissor(GLbyte * pc)
1076 {
1077 glScissor((GLint) bswap_CARD32(pc + 0),
1078 (GLint) bswap_CARD32(pc + 4),
1079 (GLsizei) bswap_CARD32(pc + 8), (GLsizei) bswap_CARD32(pc + 12));
1080 }
1081
1082 void
__glXDispSwap_ShadeModel(GLbyte * pc)1083 __glXDispSwap_ShadeModel(GLbyte * pc)
1084 {
1085 glShadeModel((GLenum) bswap_ENUM(pc + 0));
1086 }
1087
1088 void
__glXDispSwap_TexParameterf(GLbyte * pc)1089 __glXDispSwap_TexParameterf(GLbyte * pc)
1090 {
1091 glTexParameterf((GLenum) bswap_ENUM(pc + 0),
1092 (GLenum) bswap_ENUM(pc + 4),
1093 (GLfloat) bswap_FLOAT32(pc + 8));
1094 }
1095
1096 void
__glXDispSwap_TexParameterfv(GLbyte * pc)1097 __glXDispSwap_TexParameterfv(GLbyte * pc)
1098 {
1099 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1100 const GLfloat *params;
1101
1102 params =
1103 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
1104 __glTexParameterfv_size(pname));
1105
1106 glTexParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
1107 }
1108
1109 void
__glXDispSwap_TexParameteri(GLbyte * pc)1110 __glXDispSwap_TexParameteri(GLbyte * pc)
1111 {
1112 glTexParameteri((GLenum) bswap_ENUM(pc + 0),
1113 (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
1114 }
1115
1116 void
__glXDispSwap_TexParameteriv(GLbyte * pc)1117 __glXDispSwap_TexParameteriv(GLbyte * pc)
1118 {
1119 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1120 const GLint *params;
1121
1122 params =
1123 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
1124 __glTexParameteriv_size(pname));
1125
1126 glTexParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
1127 }
1128
1129 void
__glXDispSwap_TexImage1D(GLbyte * pc)1130 __glXDispSwap_TexImage1D(GLbyte * pc)
1131 {
1132 const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
1133 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
1134
1135 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
1136 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
1137 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
1138 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
1139 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
1140 (GLint) bswap_CARD32(&hdr->skipPixels));
1141 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
1142
1143 glTexImage1D((GLenum) bswap_ENUM(pc + 20),
1144 (GLint) bswap_CARD32(pc + 24),
1145 (GLint) bswap_CARD32(pc + 28),
1146 (GLsizei) bswap_CARD32(pc + 32),
1147 (GLint) bswap_CARD32(pc + 40),
1148 (GLenum) bswap_ENUM(pc + 44),
1149 (GLenum) bswap_ENUM(pc + 48), pixels);
1150 }
1151
1152 void
__glXDispSwap_TexImage2D(GLbyte * pc)1153 __glXDispSwap_TexImage2D(GLbyte * pc)
1154 {
1155 const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
1156 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
1157
1158 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
1159 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
1160 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
1161 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
1162 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
1163 (GLint) bswap_CARD32(&hdr->skipPixels));
1164 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
1165
1166 glTexImage2D((GLenum) bswap_ENUM(pc + 20),
1167 (GLint) bswap_CARD32(pc + 24),
1168 (GLint) bswap_CARD32(pc + 28),
1169 (GLsizei) bswap_CARD32(pc + 32),
1170 (GLsizei) bswap_CARD32(pc + 36),
1171 (GLint) bswap_CARD32(pc + 40),
1172 (GLenum) bswap_ENUM(pc + 44),
1173 (GLenum) bswap_ENUM(pc + 48), pixels);
1174 }
1175
1176 void
__glXDispSwap_TexEnvf(GLbyte * pc)1177 __glXDispSwap_TexEnvf(GLbyte * pc)
1178 {
1179 glTexEnvf((GLenum) bswap_ENUM(pc + 0),
1180 (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
1181 }
1182
1183 void
__glXDispSwap_TexEnvfv(GLbyte * pc)1184 __glXDispSwap_TexEnvfv(GLbyte * pc)
1185 {
1186 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1187 const GLfloat *params;
1188
1189 params =
1190 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
1191 __glTexEnvfv_size(pname));
1192
1193 glTexEnvfv((GLenum) bswap_ENUM(pc + 0), pname, params);
1194 }
1195
1196 void
__glXDispSwap_TexEnvi(GLbyte * pc)1197 __glXDispSwap_TexEnvi(GLbyte * pc)
1198 {
1199 glTexEnvi((GLenum) bswap_ENUM(pc + 0),
1200 (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
1201 }
1202
1203 void
__glXDispSwap_TexEnviv(GLbyte * pc)1204 __glXDispSwap_TexEnviv(GLbyte * pc)
1205 {
1206 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1207 const GLint *params;
1208
1209 params =
1210 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
1211 __glTexEnviv_size(pname));
1212
1213 glTexEnviv((GLenum) bswap_ENUM(pc + 0), pname, params);
1214 }
1215
1216 void
__glXDispSwap_TexGend(GLbyte * pc)1217 __glXDispSwap_TexGend(GLbyte * pc)
1218 {
1219 #ifdef __GLX_ALIGN64
1220 if ((unsigned long) (pc) & 7) {
1221 (void) memmove(pc - 4, pc, 16);
1222 pc -= 4;
1223 }
1224 #endif
1225
1226 glTexGend((GLenum) bswap_ENUM(pc + 8),
1227 (GLenum) bswap_ENUM(pc + 12), (GLdouble) bswap_FLOAT64(pc + 0));
1228 }
1229
1230 void
__glXDispSwap_TexGendv(GLbyte * pc)1231 __glXDispSwap_TexGendv(GLbyte * pc)
1232 {
1233 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1234 const GLdouble *params;
1235
1236 #ifdef __GLX_ALIGN64
1237 const GLuint compsize = __glTexGendv_size(pname);
1238 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
1239
1240 if ((unsigned long) (pc) & 7) {
1241 (void) memmove(pc - 4, pc, cmdlen);
1242 pc -= 4;
1243 }
1244 #endif
1245
1246 params =
1247 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
1248 __glTexGendv_size(pname));
1249
1250 glTexGendv((GLenum) bswap_ENUM(pc + 0), pname, params);
1251 }
1252
1253 void
__glXDispSwap_TexGenf(GLbyte * pc)1254 __glXDispSwap_TexGenf(GLbyte * pc)
1255 {
1256 glTexGenf((GLenum) bswap_ENUM(pc + 0),
1257 (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
1258 }
1259
1260 void
__glXDispSwap_TexGenfv(GLbyte * pc)1261 __glXDispSwap_TexGenfv(GLbyte * pc)
1262 {
1263 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1264 const GLfloat *params;
1265
1266 params =
1267 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
1268 __glTexGenfv_size(pname));
1269
1270 glTexGenfv((GLenum) bswap_ENUM(pc + 0), pname, params);
1271 }
1272
1273 void
__glXDispSwap_TexGeni(GLbyte * pc)1274 __glXDispSwap_TexGeni(GLbyte * pc)
1275 {
1276 glTexGeni((GLenum) bswap_ENUM(pc + 0),
1277 (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
1278 }
1279
1280 void
__glXDispSwap_TexGeniv(GLbyte * pc)1281 __glXDispSwap_TexGeniv(GLbyte * pc)
1282 {
1283 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1284 const GLint *params;
1285
1286 params =
1287 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
1288 __glTexGeniv_size(pname));
1289
1290 glTexGeniv((GLenum) bswap_ENUM(pc + 0), pname, params);
1291 }
1292
1293 void
__glXDispSwap_InitNames(GLbyte * pc)1294 __glXDispSwap_InitNames(GLbyte * pc)
1295 {
1296 glInitNames();
1297 }
1298
1299 void
__glXDispSwap_LoadName(GLbyte * pc)1300 __glXDispSwap_LoadName(GLbyte * pc)
1301 {
1302 glLoadName((GLuint) bswap_CARD32(pc + 0));
1303 }
1304
1305 void
__glXDispSwap_PassThrough(GLbyte * pc)1306 __glXDispSwap_PassThrough(GLbyte * pc)
1307 {
1308 glPassThrough((GLfloat) bswap_FLOAT32(pc + 0));
1309 }
1310
1311 void
__glXDispSwap_PopName(GLbyte * pc)1312 __glXDispSwap_PopName(GLbyte * pc)
1313 {
1314 glPopName();
1315 }
1316
1317 void
__glXDispSwap_PushName(GLbyte * pc)1318 __glXDispSwap_PushName(GLbyte * pc)
1319 {
1320 glPushName((GLuint) bswap_CARD32(pc + 0));
1321 }
1322
1323 void
__glXDispSwap_DrawBuffer(GLbyte * pc)1324 __glXDispSwap_DrawBuffer(GLbyte * pc)
1325 {
1326 glDrawBuffer((GLenum) bswap_ENUM(pc + 0));
1327 }
1328
1329 void
__glXDispSwap_Clear(GLbyte * pc)1330 __glXDispSwap_Clear(GLbyte * pc)
1331 {
1332 glClear((GLbitfield) bswap_CARD32(pc + 0));
1333 }
1334
1335 void
__glXDispSwap_ClearAccum(GLbyte * pc)1336 __glXDispSwap_ClearAccum(GLbyte * pc)
1337 {
1338 glClearAccum((GLfloat) bswap_FLOAT32(pc + 0),
1339 (GLfloat) bswap_FLOAT32(pc + 4),
1340 (GLfloat) bswap_FLOAT32(pc + 8),
1341 (GLfloat) bswap_FLOAT32(pc + 12));
1342 }
1343
1344 void
__glXDispSwap_ClearIndex(GLbyte * pc)1345 __glXDispSwap_ClearIndex(GLbyte * pc)
1346 {
1347 glClearIndex((GLfloat) bswap_FLOAT32(pc + 0));
1348 }
1349
1350 void
__glXDispSwap_ClearColor(GLbyte * pc)1351 __glXDispSwap_ClearColor(GLbyte * pc)
1352 {
1353 glClearColor((GLclampf) bswap_FLOAT32(pc + 0),
1354 (GLclampf) bswap_FLOAT32(pc + 4),
1355 (GLclampf) bswap_FLOAT32(pc + 8),
1356 (GLclampf) bswap_FLOAT32(pc + 12));
1357 }
1358
1359 void
__glXDispSwap_ClearStencil(GLbyte * pc)1360 __glXDispSwap_ClearStencil(GLbyte * pc)
1361 {
1362 glClearStencil((GLint) bswap_CARD32(pc + 0));
1363 }
1364
1365 void
__glXDispSwap_ClearDepth(GLbyte * pc)1366 __glXDispSwap_ClearDepth(GLbyte * pc)
1367 {
1368 #ifdef __GLX_ALIGN64
1369 if ((unsigned long) (pc) & 7) {
1370 (void) memmove(pc - 4, pc, 8);
1371 pc -= 4;
1372 }
1373 #endif
1374
1375 glClearDepth((GLclampd) bswap_FLOAT64(pc + 0));
1376 }
1377
1378 void
__glXDispSwap_StencilMask(GLbyte * pc)1379 __glXDispSwap_StencilMask(GLbyte * pc)
1380 {
1381 glStencilMask((GLuint) bswap_CARD32(pc + 0));
1382 }
1383
1384 void
__glXDispSwap_ColorMask(GLbyte * pc)1385 __glXDispSwap_ColorMask(GLbyte * pc)
1386 {
1387 glColorMask(*(GLboolean *) (pc + 0),
1388 *(GLboolean *) (pc + 1),
1389 *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3));
1390 }
1391
1392 void
__glXDispSwap_DepthMask(GLbyte * pc)1393 __glXDispSwap_DepthMask(GLbyte * pc)
1394 {
1395 glDepthMask(*(GLboolean *) (pc + 0));
1396 }
1397
1398 void
__glXDispSwap_IndexMask(GLbyte * pc)1399 __glXDispSwap_IndexMask(GLbyte * pc)
1400 {
1401 glIndexMask((GLuint) bswap_CARD32(pc + 0));
1402 }
1403
1404 void
__glXDispSwap_Accum(GLbyte * pc)1405 __glXDispSwap_Accum(GLbyte * pc)
1406 {
1407 glAccum((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
1408 }
1409
1410 void
__glXDispSwap_Disable(GLbyte * pc)1411 __glXDispSwap_Disable(GLbyte * pc)
1412 {
1413 glDisable((GLenum) bswap_ENUM(pc + 0));
1414 }
1415
1416 void
__glXDispSwap_Enable(GLbyte * pc)1417 __glXDispSwap_Enable(GLbyte * pc)
1418 {
1419 glEnable((GLenum) bswap_ENUM(pc + 0));
1420 }
1421
1422 void
__glXDispSwap_PopAttrib(GLbyte * pc)1423 __glXDispSwap_PopAttrib(GLbyte * pc)
1424 {
1425 glPopAttrib();
1426 }
1427
1428 void
__glXDispSwap_PushAttrib(GLbyte * pc)1429 __glXDispSwap_PushAttrib(GLbyte * pc)
1430 {
1431 glPushAttrib((GLbitfield) bswap_CARD32(pc + 0));
1432 }
1433
1434 void
__glXDispSwap_MapGrid1d(GLbyte * pc)1435 __glXDispSwap_MapGrid1d(GLbyte * pc)
1436 {
1437 #ifdef __GLX_ALIGN64
1438 if ((unsigned long) (pc) & 7) {
1439 (void) memmove(pc - 4, pc, 20);
1440 pc -= 4;
1441 }
1442 #endif
1443
1444 glMapGrid1d((GLint) bswap_CARD32(pc + 16),
1445 (GLdouble) bswap_FLOAT64(pc + 0),
1446 (GLdouble) bswap_FLOAT64(pc + 8));
1447 }
1448
1449 void
__glXDispSwap_MapGrid1f(GLbyte * pc)1450 __glXDispSwap_MapGrid1f(GLbyte * pc)
1451 {
1452 glMapGrid1f((GLint) bswap_CARD32(pc + 0),
1453 (GLfloat) bswap_FLOAT32(pc + 4),
1454 (GLfloat) bswap_FLOAT32(pc + 8));
1455 }
1456
1457 void
__glXDispSwap_MapGrid2d(GLbyte * pc)1458 __glXDispSwap_MapGrid2d(GLbyte * pc)
1459 {
1460 #ifdef __GLX_ALIGN64
1461 if ((unsigned long) (pc) & 7) {
1462 (void) memmove(pc - 4, pc, 40);
1463 pc -= 4;
1464 }
1465 #endif
1466
1467 glMapGrid2d((GLint) bswap_CARD32(pc + 32),
1468 (GLdouble) bswap_FLOAT64(pc + 0),
1469 (GLdouble) bswap_FLOAT64(pc + 8),
1470 (GLint) bswap_CARD32(pc + 36),
1471 (GLdouble) bswap_FLOAT64(pc + 16),
1472 (GLdouble) bswap_FLOAT64(pc + 24));
1473 }
1474
1475 void
__glXDispSwap_MapGrid2f(GLbyte * pc)1476 __glXDispSwap_MapGrid2f(GLbyte * pc)
1477 {
1478 glMapGrid2f((GLint) bswap_CARD32(pc + 0),
1479 (GLfloat) bswap_FLOAT32(pc + 4),
1480 (GLfloat) bswap_FLOAT32(pc + 8),
1481 (GLint) bswap_CARD32(pc + 12),
1482 (GLfloat) bswap_FLOAT32(pc + 16),
1483 (GLfloat) bswap_FLOAT32(pc + 20));
1484 }
1485
1486 void
__glXDispSwap_EvalCoord1dv(GLbyte * pc)1487 __glXDispSwap_EvalCoord1dv(GLbyte * pc)
1488 {
1489 #ifdef __GLX_ALIGN64
1490 if ((unsigned long) (pc) & 7) {
1491 (void) memmove(pc - 4, pc, 8);
1492 pc -= 4;
1493 }
1494 #endif
1495
1496 glEvalCoord1dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
1497 }
1498
1499 void
__glXDispSwap_EvalCoord1fv(GLbyte * pc)1500 __glXDispSwap_EvalCoord1fv(GLbyte * pc)
1501 {
1502 glEvalCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
1503 }
1504
1505 void
__glXDispSwap_EvalCoord2dv(GLbyte * pc)1506 __glXDispSwap_EvalCoord2dv(GLbyte * pc)
1507 {
1508 #ifdef __GLX_ALIGN64
1509 if ((unsigned long) (pc) & 7) {
1510 (void) memmove(pc - 4, pc, 16);
1511 pc -= 4;
1512 }
1513 #endif
1514
1515 glEvalCoord2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
1516 }
1517
1518 void
__glXDispSwap_EvalCoord2fv(GLbyte * pc)1519 __glXDispSwap_EvalCoord2fv(GLbyte * pc)
1520 {
1521 glEvalCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
1522 }
1523
1524 void
__glXDispSwap_EvalMesh1(GLbyte * pc)1525 __glXDispSwap_EvalMesh1(GLbyte * pc)
1526 {
1527 glEvalMesh1((GLenum) bswap_ENUM(pc + 0),
1528 (GLint) bswap_CARD32(pc + 4), (GLint) bswap_CARD32(pc + 8));
1529 }
1530
1531 void
__glXDispSwap_EvalPoint1(GLbyte * pc)1532 __glXDispSwap_EvalPoint1(GLbyte * pc)
1533 {
1534 glEvalPoint1((GLint) bswap_CARD32(pc + 0));
1535 }
1536
1537 void
__glXDispSwap_EvalMesh2(GLbyte * pc)1538 __glXDispSwap_EvalMesh2(GLbyte * pc)
1539 {
1540 glEvalMesh2((GLenum) bswap_ENUM(pc + 0),
1541 (GLint) bswap_CARD32(pc + 4),
1542 (GLint) bswap_CARD32(pc + 8),
1543 (GLint) bswap_CARD32(pc + 12), (GLint) bswap_CARD32(pc + 16));
1544 }
1545
1546 void
__glXDispSwap_EvalPoint2(GLbyte * pc)1547 __glXDispSwap_EvalPoint2(GLbyte * pc)
1548 {
1549 glEvalPoint2((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4));
1550 }
1551
1552 void
__glXDispSwap_AlphaFunc(GLbyte * pc)1553 __glXDispSwap_AlphaFunc(GLbyte * pc)
1554 {
1555 glAlphaFunc((GLenum) bswap_ENUM(pc + 0), (GLclampf) bswap_FLOAT32(pc + 4));
1556 }
1557
1558 void
__glXDispSwap_BlendFunc(GLbyte * pc)1559 __glXDispSwap_BlendFunc(GLbyte * pc)
1560 {
1561 glBlendFunc((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
1562 }
1563
1564 void
__glXDispSwap_LogicOp(GLbyte * pc)1565 __glXDispSwap_LogicOp(GLbyte * pc)
1566 {
1567 glLogicOp((GLenum) bswap_ENUM(pc + 0));
1568 }
1569
1570 void
__glXDispSwap_StencilFunc(GLbyte * pc)1571 __glXDispSwap_StencilFunc(GLbyte * pc)
1572 {
1573 glStencilFunc((GLenum) bswap_ENUM(pc + 0),
1574 (GLint) bswap_CARD32(pc + 4), (GLuint) bswap_CARD32(pc + 8));
1575 }
1576
1577 void
__glXDispSwap_StencilOp(GLbyte * pc)1578 __glXDispSwap_StencilOp(GLbyte * pc)
1579 {
1580 glStencilOp((GLenum) bswap_ENUM(pc + 0),
1581 (GLenum) bswap_ENUM(pc + 4), (GLenum) bswap_ENUM(pc + 8));
1582 }
1583
1584 void
__glXDispSwap_DepthFunc(GLbyte * pc)1585 __glXDispSwap_DepthFunc(GLbyte * pc)
1586 {
1587 glDepthFunc((GLenum) bswap_ENUM(pc + 0));
1588 }
1589
1590 void
__glXDispSwap_PixelZoom(GLbyte * pc)1591 __glXDispSwap_PixelZoom(GLbyte * pc)
1592 {
1593 glPixelZoom((GLfloat) bswap_FLOAT32(pc + 0),
1594 (GLfloat) bswap_FLOAT32(pc + 4));
1595 }
1596
1597 void
__glXDispSwap_PixelTransferf(GLbyte * pc)1598 __glXDispSwap_PixelTransferf(GLbyte * pc)
1599 {
1600 glPixelTransferf((GLenum) bswap_ENUM(pc + 0),
1601 (GLfloat) bswap_FLOAT32(pc + 4));
1602 }
1603
1604 void
__glXDispSwap_PixelTransferi(GLbyte * pc)1605 __glXDispSwap_PixelTransferi(GLbyte * pc)
1606 {
1607 glPixelTransferi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
1608 }
1609
1610 int
__glXDispSwap_PixelStoref(__GLXclientState * cl,GLbyte * pc)1611 __glXDispSwap_PixelStoref(__GLXclientState * cl, GLbyte * pc)
1612 {
1613 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1614 int error;
1615 __GLXcontext *const cx =
1616 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1617
1618 pc += __GLX_SINGLE_HDR_SIZE;
1619 if (cx != NULL) {
1620 glPixelStoref((GLenum) bswap_ENUM(pc + 0),
1621 (GLfloat) bswap_FLOAT32(pc + 4));
1622 error = Success;
1623 }
1624
1625 return error;
1626 }
1627
1628 int
__glXDispSwap_PixelStorei(__GLXclientState * cl,GLbyte * pc)1629 __glXDispSwap_PixelStorei(__GLXclientState * cl, GLbyte * pc)
1630 {
1631 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1632 int error;
1633 __GLXcontext *const cx =
1634 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1635
1636 pc += __GLX_SINGLE_HDR_SIZE;
1637 if (cx != NULL) {
1638 glPixelStorei((GLenum) bswap_ENUM(pc + 0),
1639 (GLint) bswap_CARD32(pc + 4));
1640 error = Success;
1641 }
1642
1643 return error;
1644 }
1645
1646 void
__glXDispSwap_PixelMapfv(GLbyte * pc)1647 __glXDispSwap_PixelMapfv(GLbyte * pc)
1648 {
1649 const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4);
1650
1651 glPixelMapfv((GLenum) bswap_ENUM(pc + 0),
1652 mapsize,
1653 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), 0));
1654 }
1655
1656 void
__glXDispSwap_PixelMapuiv(GLbyte * pc)1657 __glXDispSwap_PixelMapuiv(GLbyte * pc)
1658 {
1659 const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4);
1660
1661 glPixelMapuiv((GLenum) bswap_ENUM(pc + 0),
1662 mapsize,
1663 (const GLuint *) bswap_32_array((uint32_t *) (pc + 8), 0));
1664 }
1665
1666 void
__glXDispSwap_PixelMapusv(GLbyte * pc)1667 __glXDispSwap_PixelMapusv(GLbyte * pc)
1668 {
1669 const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4);
1670
1671 glPixelMapusv((GLenum) bswap_ENUM(pc + 0),
1672 mapsize,
1673 (const GLushort *) bswap_16_array((uint16_t *) (pc + 8), 0));
1674 }
1675
1676 void
__glXDispSwap_ReadBuffer(GLbyte * pc)1677 __glXDispSwap_ReadBuffer(GLbyte * pc)
1678 {
1679 glReadBuffer((GLenum) bswap_ENUM(pc + 0));
1680 }
1681
1682 void
__glXDispSwap_CopyPixels(GLbyte * pc)1683 __glXDispSwap_CopyPixels(GLbyte * pc)
1684 {
1685 glCopyPixels((GLint) bswap_CARD32(pc + 0),
1686 (GLint) bswap_CARD32(pc + 4),
1687 (GLsizei) bswap_CARD32(pc + 8),
1688 (GLsizei) bswap_CARD32(pc + 12), (GLenum) bswap_ENUM(pc + 16));
1689 }
1690
1691 void
__glXDispSwap_DrawPixels(GLbyte * pc)1692 __glXDispSwap_DrawPixels(GLbyte * pc)
1693 {
1694 const GLvoid *const pixels = (const GLvoid *) ((pc + 36));
1695 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
1696
1697 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
1698 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
1699 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
1700 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
1701 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
1702 (GLint) bswap_CARD32(&hdr->skipPixels));
1703 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
1704
1705 glDrawPixels((GLsizei) bswap_CARD32(pc + 20),
1706 (GLsizei) bswap_CARD32(pc + 24),
1707 (GLenum) bswap_ENUM(pc + 28),
1708 (GLenum) bswap_ENUM(pc + 32), pixels);
1709 }
1710
1711 int
__glXDispSwap_GetBooleanv(__GLXclientState * cl,GLbyte * pc)1712 __glXDispSwap_GetBooleanv(__GLXclientState * cl, GLbyte * pc)
1713 {
1714 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1715 int error;
1716 __GLXcontext *const cx =
1717 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1718
1719 pc += __GLX_SINGLE_HDR_SIZE;
1720 if (cx != NULL) {
1721 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
1722
1723 const GLuint compsize = __glGetBooleanv_size(pname);
1724 GLboolean answerBuffer[200];
1725 GLboolean *params =
1726 __glXGetAnswerBuffer(cl, compsize, answerBuffer,
1727 sizeof(answerBuffer), 1);
1728
1729 if (params == NULL)
1730 return BadAlloc;
1731 __glXClearErrorOccured();
1732
1733 glGetBooleanv(pname, params);
1734 __glXSendReplySwap(cl->client, params, compsize, 1, GL_FALSE, 0);
1735 error = Success;
1736 }
1737
1738 return error;
1739 }
1740
1741 int
__glXDispSwap_GetClipPlane(__GLXclientState * cl,GLbyte * pc)1742 __glXDispSwap_GetClipPlane(__GLXclientState * cl, GLbyte * pc)
1743 {
1744 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1745 int error;
1746 __GLXcontext *const cx =
1747 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1748
1749 pc += __GLX_SINGLE_HDR_SIZE;
1750 if (cx != NULL) {
1751 GLdouble equation[4];
1752
1753 glGetClipPlane((GLenum) bswap_ENUM(pc + 0), equation);
1754 (void) bswap_64_array((uint64_t *) equation, 4);
1755 __glXSendReplySwap(cl->client, equation, 4, 8, GL_TRUE, 0);
1756 error = Success;
1757 }
1758
1759 return error;
1760 }
1761
1762 int
__glXDispSwap_GetDoublev(__GLXclientState * cl,GLbyte * pc)1763 __glXDispSwap_GetDoublev(__GLXclientState * cl, GLbyte * pc)
1764 {
1765 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1766 int error;
1767 __GLXcontext *const cx =
1768 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1769
1770 pc += __GLX_SINGLE_HDR_SIZE;
1771 if (cx != NULL) {
1772 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
1773
1774 const GLuint compsize = __glGetDoublev_size(pname);
1775 GLdouble answerBuffer[200];
1776 GLdouble *params =
1777 __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
1778 sizeof(answerBuffer), 8);
1779
1780 if (params == NULL)
1781 return BadAlloc;
1782 __glXClearErrorOccured();
1783
1784 glGetDoublev(pname, params);
1785 (void) bswap_64_array((uint64_t *) params, compsize);
1786 __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
1787 error = Success;
1788 }
1789
1790 return error;
1791 }
1792
1793 int
__glXDispSwap_GetError(__GLXclientState * cl,GLbyte * pc)1794 __glXDispSwap_GetError(__GLXclientState * cl, GLbyte * pc)
1795 {
1796 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1797 int error;
1798 __GLXcontext *const cx =
1799 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1800
1801 pc += __GLX_SINGLE_HDR_SIZE;
1802 if (cx != NULL) {
1803 GLenum retval;
1804
1805 retval = glGetError();
1806 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
1807 error = Success;
1808 }
1809
1810 return error;
1811 }
1812
1813 int
__glXDispSwap_GetFloatv(__GLXclientState * cl,GLbyte * pc)1814 __glXDispSwap_GetFloatv(__GLXclientState * cl, GLbyte * pc)
1815 {
1816 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1817 int error;
1818 __GLXcontext *const cx =
1819 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1820
1821 pc += __GLX_SINGLE_HDR_SIZE;
1822 if (cx != NULL) {
1823 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
1824
1825 const GLuint compsize = __glGetFloatv_size(pname);
1826 GLfloat answerBuffer[200];
1827 GLfloat *params =
1828 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
1829 sizeof(answerBuffer), 4);
1830
1831 if (params == NULL)
1832 return BadAlloc;
1833 __glXClearErrorOccured();
1834
1835 glGetFloatv(pname, params);
1836 (void) bswap_32_array((uint32_t *) params, compsize);
1837 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
1838 error = Success;
1839 }
1840
1841 return error;
1842 }
1843
1844 int
__glXDispSwap_GetIntegerv(__GLXclientState * cl,GLbyte * pc)1845 __glXDispSwap_GetIntegerv(__GLXclientState * cl, GLbyte * pc)
1846 {
1847 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1848 int error;
1849 __GLXcontext *const cx =
1850 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1851
1852 pc += __GLX_SINGLE_HDR_SIZE;
1853 if (cx != NULL) {
1854 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
1855
1856 const GLuint compsize = __glGetIntegerv_size(pname);
1857 GLint answerBuffer[200];
1858 GLint *params =
1859 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
1860 sizeof(answerBuffer), 4);
1861
1862 if (params == NULL)
1863 return BadAlloc;
1864 __glXClearErrorOccured();
1865
1866 glGetIntegerv(pname, params);
1867 (void) bswap_32_array((uint32_t *) params, compsize);
1868 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
1869 error = Success;
1870 }
1871
1872 return error;
1873 }
1874
1875 int
__glXDispSwap_GetLightfv(__GLXclientState * cl,GLbyte * pc)1876 __glXDispSwap_GetLightfv(__GLXclientState * cl, GLbyte * pc)
1877 {
1878 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1879 int error;
1880 __GLXcontext *const cx =
1881 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1882
1883 pc += __GLX_SINGLE_HDR_SIZE;
1884 if (cx != NULL) {
1885 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1886
1887 const GLuint compsize = __glGetLightfv_size(pname);
1888 GLfloat answerBuffer[200];
1889 GLfloat *params =
1890 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
1891 sizeof(answerBuffer), 4);
1892
1893 if (params == NULL)
1894 return BadAlloc;
1895 __glXClearErrorOccured();
1896
1897 glGetLightfv((GLenum) bswap_ENUM(pc + 0), pname, params);
1898 (void) bswap_32_array((uint32_t *) params, compsize);
1899 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
1900 error = Success;
1901 }
1902
1903 return error;
1904 }
1905
1906 int
__glXDispSwap_GetLightiv(__GLXclientState * cl,GLbyte * pc)1907 __glXDispSwap_GetLightiv(__GLXclientState * cl, GLbyte * pc)
1908 {
1909 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1910 int error;
1911 __GLXcontext *const cx =
1912 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1913
1914 pc += __GLX_SINGLE_HDR_SIZE;
1915 if (cx != NULL) {
1916 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1917
1918 const GLuint compsize = __glGetLightiv_size(pname);
1919 GLint answerBuffer[200];
1920 GLint *params =
1921 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
1922 sizeof(answerBuffer), 4);
1923
1924 if (params == NULL)
1925 return BadAlloc;
1926 __glXClearErrorOccured();
1927
1928 glGetLightiv((GLenum) bswap_ENUM(pc + 0), pname, params);
1929 (void) bswap_32_array((uint32_t *) params, compsize);
1930 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
1931 error = Success;
1932 }
1933
1934 return error;
1935 }
1936
1937 int
__glXDispSwap_GetMapdv(__GLXclientState * cl,GLbyte * pc)1938 __glXDispSwap_GetMapdv(__GLXclientState * cl, GLbyte * pc)
1939 {
1940 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1941 int error;
1942 __GLXcontext *const cx =
1943 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1944
1945 pc += __GLX_SINGLE_HDR_SIZE;
1946 if (cx != NULL) {
1947 const GLenum target = (GLenum) bswap_ENUM(pc + 0);
1948 const GLenum query = (GLenum) bswap_ENUM(pc + 4);
1949
1950 const GLuint compsize = __glGetMapdv_size(target, query);
1951 GLdouble answerBuffer[200];
1952 GLdouble *v =
1953 __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
1954 sizeof(answerBuffer), 8);
1955
1956 if (v == NULL)
1957 return BadAlloc;
1958 __glXClearErrorOccured();
1959
1960 glGetMapdv(target, query, v);
1961 (void) bswap_64_array((uint64_t *) v, compsize);
1962 __glXSendReplySwap(cl->client, v, compsize, 8, GL_FALSE, 0);
1963 error = Success;
1964 }
1965
1966 return error;
1967 }
1968
1969 int
__glXDispSwap_GetMapfv(__GLXclientState * cl,GLbyte * pc)1970 __glXDispSwap_GetMapfv(__GLXclientState * cl, GLbyte * pc)
1971 {
1972 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
1973 int error;
1974 __GLXcontext *const cx =
1975 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
1976
1977 pc += __GLX_SINGLE_HDR_SIZE;
1978 if (cx != NULL) {
1979 const GLenum target = (GLenum) bswap_ENUM(pc + 0);
1980 const GLenum query = (GLenum) bswap_ENUM(pc + 4);
1981
1982 const GLuint compsize = __glGetMapfv_size(target, query);
1983 GLfloat answerBuffer[200];
1984 GLfloat *v =
1985 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
1986 sizeof(answerBuffer), 4);
1987
1988 if (v == NULL)
1989 return BadAlloc;
1990 __glXClearErrorOccured();
1991
1992 glGetMapfv(target, query, v);
1993 (void) bswap_32_array((uint32_t *) v, compsize);
1994 __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
1995 error = Success;
1996 }
1997
1998 return error;
1999 }
2000
2001 int
__glXDispSwap_GetMapiv(__GLXclientState * cl,GLbyte * pc)2002 __glXDispSwap_GetMapiv(__GLXclientState * cl, GLbyte * pc)
2003 {
2004 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2005 int error;
2006 __GLXcontext *const cx =
2007 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2008
2009 pc += __GLX_SINGLE_HDR_SIZE;
2010 if (cx != NULL) {
2011 const GLenum target = (GLenum) bswap_ENUM(pc + 0);
2012 const GLenum query = (GLenum) bswap_ENUM(pc + 4);
2013
2014 const GLuint compsize = __glGetMapiv_size(target, query);
2015 GLint answerBuffer[200];
2016 GLint *v =
2017 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2018 sizeof(answerBuffer), 4);
2019
2020 if (v == NULL)
2021 return BadAlloc;
2022 __glXClearErrorOccured();
2023
2024 glGetMapiv(target, query, v);
2025 (void) bswap_32_array((uint32_t *) v, compsize);
2026 __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
2027 error = Success;
2028 }
2029
2030 return error;
2031 }
2032
2033 int
__glXDispSwap_GetMaterialfv(__GLXclientState * cl,GLbyte * pc)2034 __glXDispSwap_GetMaterialfv(__GLXclientState * cl, GLbyte * pc)
2035 {
2036 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2037 int error;
2038 __GLXcontext *const cx =
2039 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2040
2041 pc += __GLX_SINGLE_HDR_SIZE;
2042 if (cx != NULL) {
2043 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2044
2045 const GLuint compsize = __glGetMaterialfv_size(pname);
2046 GLfloat answerBuffer[200];
2047 GLfloat *params =
2048 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2049 sizeof(answerBuffer), 4);
2050
2051 if (params == NULL)
2052 return BadAlloc;
2053 __glXClearErrorOccured();
2054
2055 glGetMaterialfv((GLenum) bswap_ENUM(pc + 0), pname, params);
2056 (void) bswap_32_array((uint32_t *) params, compsize);
2057 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2058 error = Success;
2059 }
2060
2061 return error;
2062 }
2063
2064 int
__glXDispSwap_GetMaterialiv(__GLXclientState * cl,GLbyte * pc)2065 __glXDispSwap_GetMaterialiv(__GLXclientState * cl, GLbyte * pc)
2066 {
2067 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2068 int error;
2069 __GLXcontext *const cx =
2070 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2071
2072 pc += __GLX_SINGLE_HDR_SIZE;
2073 if (cx != NULL) {
2074 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2075
2076 const GLuint compsize = __glGetMaterialiv_size(pname);
2077 GLint answerBuffer[200];
2078 GLint *params =
2079 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2080 sizeof(answerBuffer), 4);
2081
2082 if (params == NULL)
2083 return BadAlloc;
2084 __glXClearErrorOccured();
2085
2086 glGetMaterialiv((GLenum) bswap_ENUM(pc + 0), pname, params);
2087 (void) bswap_32_array((uint32_t *) params, compsize);
2088 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2089 error = Success;
2090 }
2091
2092 return error;
2093 }
2094
2095 int
__glXDispSwap_GetPixelMapfv(__GLXclientState * cl,GLbyte * pc)2096 __glXDispSwap_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc)
2097 {
2098 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2099 int error;
2100 __GLXcontext *const cx =
2101 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2102
2103 pc += __GLX_SINGLE_HDR_SIZE;
2104 if (cx != NULL) {
2105 const GLenum map = (GLenum) bswap_ENUM(pc + 0);
2106
2107 const GLuint compsize = __glGetPixelMapfv_size(map);
2108 GLfloat answerBuffer[200];
2109 GLfloat *values =
2110 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2111 sizeof(answerBuffer), 4);
2112
2113 if (values == NULL)
2114 return BadAlloc;
2115 __glXClearErrorOccured();
2116
2117 glGetPixelMapfv(map, values);
2118 (void) bswap_32_array((uint32_t *) values, compsize);
2119 __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
2120 error = Success;
2121 }
2122
2123 return error;
2124 }
2125
2126 int
__glXDispSwap_GetPixelMapuiv(__GLXclientState * cl,GLbyte * pc)2127 __glXDispSwap_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc)
2128 {
2129 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2130 int error;
2131 __GLXcontext *const cx =
2132 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2133
2134 pc += __GLX_SINGLE_HDR_SIZE;
2135 if (cx != NULL) {
2136 const GLenum map = (GLenum) bswap_ENUM(pc + 0);
2137
2138 const GLuint compsize = __glGetPixelMapuiv_size(map);
2139 GLuint answerBuffer[200];
2140 GLuint *values =
2141 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2142 sizeof(answerBuffer), 4);
2143
2144 if (values == NULL)
2145 return BadAlloc;
2146 __glXClearErrorOccured();
2147
2148 glGetPixelMapuiv(map, values);
2149 (void) bswap_32_array((uint32_t *) values, compsize);
2150 __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
2151 error = Success;
2152 }
2153
2154 return error;
2155 }
2156
2157 int
__glXDispSwap_GetPixelMapusv(__GLXclientState * cl,GLbyte * pc)2158 __glXDispSwap_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc)
2159 {
2160 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2161 int error;
2162 __GLXcontext *const cx =
2163 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2164
2165 pc += __GLX_SINGLE_HDR_SIZE;
2166 if (cx != NULL) {
2167 const GLenum map = (GLenum) bswap_ENUM(pc + 0);
2168
2169 const GLuint compsize = __glGetPixelMapusv_size(map);
2170 GLushort answerBuffer[200];
2171 GLushort *values =
2172 __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer,
2173 sizeof(answerBuffer), 2);
2174
2175 if (values == NULL)
2176 return BadAlloc;
2177 __glXClearErrorOccured();
2178
2179 glGetPixelMapusv(map, values);
2180 (void) bswap_16_array((uint16_t *) values, compsize);
2181 __glXSendReplySwap(cl->client, values, compsize, 2, GL_FALSE, 0);
2182 error = Success;
2183 }
2184
2185 return error;
2186 }
2187
2188 int
__glXDispSwap_GetTexEnvfv(__GLXclientState * cl,GLbyte * pc)2189 __glXDispSwap_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc)
2190 {
2191 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2192 int error;
2193 __GLXcontext *const cx =
2194 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2195
2196 pc += __GLX_SINGLE_HDR_SIZE;
2197 if (cx != NULL) {
2198 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2199
2200 const GLuint compsize = __glGetTexEnvfv_size(pname);
2201 GLfloat answerBuffer[200];
2202 GLfloat *params =
2203 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2204 sizeof(answerBuffer), 4);
2205
2206 if (params == NULL)
2207 return BadAlloc;
2208 __glXClearErrorOccured();
2209
2210 glGetTexEnvfv((GLenum) bswap_ENUM(pc + 0), pname, params);
2211 (void) bswap_32_array((uint32_t *) params, compsize);
2212 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2213 error = Success;
2214 }
2215
2216 return error;
2217 }
2218
2219 int
__glXDispSwap_GetTexEnviv(__GLXclientState * cl,GLbyte * pc)2220 __glXDispSwap_GetTexEnviv(__GLXclientState * cl, GLbyte * pc)
2221 {
2222 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2223 int error;
2224 __GLXcontext *const cx =
2225 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2226
2227 pc += __GLX_SINGLE_HDR_SIZE;
2228 if (cx != NULL) {
2229 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2230
2231 const GLuint compsize = __glGetTexEnviv_size(pname);
2232 GLint answerBuffer[200];
2233 GLint *params =
2234 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2235 sizeof(answerBuffer), 4);
2236
2237 if (params == NULL)
2238 return BadAlloc;
2239 __glXClearErrorOccured();
2240
2241 glGetTexEnviv((GLenum) bswap_ENUM(pc + 0), pname, params);
2242 (void) bswap_32_array((uint32_t *) params, compsize);
2243 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2244 error = Success;
2245 }
2246
2247 return error;
2248 }
2249
2250 int
__glXDispSwap_GetTexGendv(__GLXclientState * cl,GLbyte * pc)2251 __glXDispSwap_GetTexGendv(__GLXclientState * cl, GLbyte * pc)
2252 {
2253 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2254 int error;
2255 __GLXcontext *const cx =
2256 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2257
2258 pc += __GLX_SINGLE_HDR_SIZE;
2259 if (cx != NULL) {
2260 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2261
2262 const GLuint compsize = __glGetTexGendv_size(pname);
2263 GLdouble answerBuffer[200];
2264 GLdouble *params =
2265 __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
2266 sizeof(answerBuffer), 8);
2267
2268 if (params == NULL)
2269 return BadAlloc;
2270 __glXClearErrorOccured();
2271
2272 glGetTexGendv((GLenum) bswap_ENUM(pc + 0), pname, params);
2273 (void) bswap_64_array((uint64_t *) params, compsize);
2274 __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
2275 error = Success;
2276 }
2277
2278 return error;
2279 }
2280
2281 int
__glXDispSwap_GetTexGenfv(__GLXclientState * cl,GLbyte * pc)2282 __glXDispSwap_GetTexGenfv(__GLXclientState * cl, GLbyte * pc)
2283 {
2284 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2285 int error;
2286 __GLXcontext *const cx =
2287 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2288
2289 pc += __GLX_SINGLE_HDR_SIZE;
2290 if (cx != NULL) {
2291 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2292
2293 const GLuint compsize = __glGetTexGenfv_size(pname);
2294 GLfloat answerBuffer[200];
2295 GLfloat *params =
2296 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2297 sizeof(answerBuffer), 4);
2298
2299 if (params == NULL)
2300 return BadAlloc;
2301 __glXClearErrorOccured();
2302
2303 glGetTexGenfv((GLenum) bswap_ENUM(pc + 0), pname, params);
2304 (void) bswap_32_array((uint32_t *) params, compsize);
2305 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2306 error = Success;
2307 }
2308
2309 return error;
2310 }
2311
2312 int
__glXDispSwap_GetTexGeniv(__GLXclientState * cl,GLbyte * pc)2313 __glXDispSwap_GetTexGeniv(__GLXclientState * cl, GLbyte * pc)
2314 {
2315 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2316 int error;
2317 __GLXcontext *const cx =
2318 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2319
2320 pc += __GLX_SINGLE_HDR_SIZE;
2321 if (cx != NULL) {
2322 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2323
2324 const GLuint compsize = __glGetTexGeniv_size(pname);
2325 GLint answerBuffer[200];
2326 GLint *params =
2327 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2328 sizeof(answerBuffer), 4);
2329
2330 if (params == NULL)
2331 return BadAlloc;
2332 __glXClearErrorOccured();
2333
2334 glGetTexGeniv((GLenum) bswap_ENUM(pc + 0), pname, params);
2335 (void) bswap_32_array((uint32_t *) params, compsize);
2336 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2337 error = Success;
2338 }
2339
2340 return error;
2341 }
2342
2343 int
__glXDispSwap_GetTexParameterfv(__GLXclientState * cl,GLbyte * pc)2344 __glXDispSwap_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc)
2345 {
2346 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2347 int error;
2348 __GLXcontext *const cx =
2349 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2350
2351 pc += __GLX_SINGLE_HDR_SIZE;
2352 if (cx != NULL) {
2353 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2354
2355 const GLuint compsize = __glGetTexParameterfv_size(pname);
2356 GLfloat answerBuffer[200];
2357 GLfloat *params =
2358 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2359 sizeof(answerBuffer), 4);
2360
2361 if (params == NULL)
2362 return BadAlloc;
2363 __glXClearErrorOccured();
2364
2365 glGetTexParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
2366 (void) bswap_32_array((uint32_t *) params, compsize);
2367 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2368 error = Success;
2369 }
2370
2371 return error;
2372 }
2373
2374 int
__glXDispSwap_GetTexParameteriv(__GLXclientState * cl,GLbyte * pc)2375 __glXDispSwap_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc)
2376 {
2377 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2378 int error;
2379 __GLXcontext *const cx =
2380 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2381
2382 pc += __GLX_SINGLE_HDR_SIZE;
2383 if (cx != NULL) {
2384 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
2385
2386 const GLuint compsize = __glGetTexParameteriv_size(pname);
2387 GLint answerBuffer[200];
2388 GLint *params =
2389 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2390 sizeof(answerBuffer), 4);
2391
2392 if (params == NULL)
2393 return BadAlloc;
2394 __glXClearErrorOccured();
2395
2396 glGetTexParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
2397 (void) bswap_32_array((uint32_t *) params, compsize);
2398 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2399 error = Success;
2400 }
2401
2402 return error;
2403 }
2404
2405 int
__glXDispSwap_GetTexLevelParameterfv(__GLXclientState * cl,GLbyte * pc)2406 __glXDispSwap_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc)
2407 {
2408 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2409 int error;
2410 __GLXcontext *const cx =
2411 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2412
2413 pc += __GLX_SINGLE_HDR_SIZE;
2414 if (cx != NULL) {
2415 const GLenum pname = (GLenum) bswap_ENUM(pc + 8);
2416
2417 const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
2418 GLfloat answerBuffer[200];
2419 GLfloat *params =
2420 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2421 sizeof(answerBuffer), 4);
2422
2423 if (params == NULL)
2424 return BadAlloc;
2425 __glXClearErrorOccured();
2426
2427 glGetTexLevelParameterfv((GLenum) bswap_ENUM(pc + 0),
2428 (GLint) bswap_CARD32(pc + 4), pname, params);
2429 (void) bswap_32_array((uint32_t *) params, compsize);
2430 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2431 error = Success;
2432 }
2433
2434 return error;
2435 }
2436
2437 int
__glXDispSwap_GetTexLevelParameteriv(__GLXclientState * cl,GLbyte * pc)2438 __glXDispSwap_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc)
2439 {
2440 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2441 int error;
2442 __GLXcontext *const cx =
2443 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2444
2445 pc += __GLX_SINGLE_HDR_SIZE;
2446 if (cx != NULL) {
2447 const GLenum pname = (GLenum) bswap_ENUM(pc + 8);
2448
2449 const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
2450 GLint answerBuffer[200];
2451 GLint *params =
2452 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
2453 sizeof(answerBuffer), 4);
2454
2455 if (params == NULL)
2456 return BadAlloc;
2457 __glXClearErrorOccured();
2458
2459 glGetTexLevelParameteriv((GLenum) bswap_ENUM(pc + 0),
2460 (GLint) bswap_CARD32(pc + 4), pname, params);
2461 (void) bswap_32_array((uint32_t *) params, compsize);
2462 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
2463 error = Success;
2464 }
2465
2466 return error;
2467 }
2468
2469 int
__glXDispSwap_IsEnabled(__GLXclientState * cl,GLbyte * pc)2470 __glXDispSwap_IsEnabled(__GLXclientState * cl, GLbyte * pc)
2471 {
2472 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2473 int error;
2474 __GLXcontext *const cx =
2475 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2476
2477 pc += __GLX_SINGLE_HDR_SIZE;
2478 if (cx != NULL) {
2479 GLboolean retval;
2480
2481 retval = glIsEnabled((GLenum) bswap_ENUM(pc + 0));
2482 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2483 error = Success;
2484 }
2485
2486 return error;
2487 }
2488
2489 int
__glXDispSwap_IsList(__GLXclientState * cl,GLbyte * pc)2490 __glXDispSwap_IsList(__GLXclientState * cl, GLbyte * pc)
2491 {
2492 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2493 int error;
2494 __GLXcontext *const cx =
2495 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2496
2497 pc += __GLX_SINGLE_HDR_SIZE;
2498 if (cx != NULL) {
2499 GLboolean retval;
2500
2501 retval = glIsList((GLuint) bswap_CARD32(pc + 0));
2502 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2503 error = Success;
2504 }
2505
2506 return error;
2507 }
2508
2509 void
__glXDispSwap_DepthRange(GLbyte * pc)2510 __glXDispSwap_DepthRange(GLbyte * pc)
2511 {
2512 #ifdef __GLX_ALIGN64
2513 if ((unsigned long) (pc) & 7) {
2514 (void) memmove(pc - 4, pc, 16);
2515 pc -= 4;
2516 }
2517 #endif
2518
2519 glDepthRange((GLclampd) bswap_FLOAT64(pc + 0),
2520 (GLclampd) bswap_FLOAT64(pc + 8));
2521 }
2522
2523 void
__glXDispSwap_Frustum(GLbyte * pc)2524 __glXDispSwap_Frustum(GLbyte * pc)
2525 {
2526 #ifdef __GLX_ALIGN64
2527 if ((unsigned long) (pc) & 7) {
2528 (void) memmove(pc - 4, pc, 48);
2529 pc -= 4;
2530 }
2531 #endif
2532
2533 glFrustum((GLdouble) bswap_FLOAT64(pc + 0),
2534 (GLdouble) bswap_FLOAT64(pc + 8),
2535 (GLdouble) bswap_FLOAT64(pc + 16),
2536 (GLdouble) bswap_FLOAT64(pc + 24),
2537 (GLdouble) bswap_FLOAT64(pc + 32),
2538 (GLdouble) bswap_FLOAT64(pc + 40));
2539 }
2540
2541 void
__glXDispSwap_LoadIdentity(GLbyte * pc)2542 __glXDispSwap_LoadIdentity(GLbyte * pc)
2543 {
2544 glLoadIdentity();
2545 }
2546
2547 void
__glXDispSwap_LoadMatrixf(GLbyte * pc)2548 __glXDispSwap_LoadMatrixf(GLbyte * pc)
2549 {
2550 glLoadMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16));
2551 }
2552
2553 void
__glXDispSwap_LoadMatrixd(GLbyte * pc)2554 __glXDispSwap_LoadMatrixd(GLbyte * pc)
2555 {
2556 #ifdef __GLX_ALIGN64
2557 if ((unsigned long) (pc) & 7) {
2558 (void) memmove(pc - 4, pc, 128);
2559 pc -= 4;
2560 }
2561 #endif
2562
2563 glLoadMatrixd((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 16));
2564 }
2565
2566 void
__glXDispSwap_MatrixMode(GLbyte * pc)2567 __glXDispSwap_MatrixMode(GLbyte * pc)
2568 {
2569 glMatrixMode((GLenum) bswap_ENUM(pc + 0));
2570 }
2571
2572 void
__glXDispSwap_MultMatrixf(GLbyte * pc)2573 __glXDispSwap_MultMatrixf(GLbyte * pc)
2574 {
2575 glMultMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16));
2576 }
2577
2578 void
__glXDispSwap_MultMatrixd(GLbyte * pc)2579 __glXDispSwap_MultMatrixd(GLbyte * pc)
2580 {
2581 #ifdef __GLX_ALIGN64
2582 if ((unsigned long) (pc) & 7) {
2583 (void) memmove(pc - 4, pc, 128);
2584 pc -= 4;
2585 }
2586 #endif
2587
2588 glMultMatrixd((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 16));
2589 }
2590
2591 void
__glXDispSwap_Ortho(GLbyte * pc)2592 __glXDispSwap_Ortho(GLbyte * pc)
2593 {
2594 #ifdef __GLX_ALIGN64
2595 if ((unsigned long) (pc) & 7) {
2596 (void) memmove(pc - 4, pc, 48);
2597 pc -= 4;
2598 }
2599 #endif
2600
2601 glOrtho((GLdouble) bswap_FLOAT64(pc + 0),
2602 (GLdouble) bswap_FLOAT64(pc + 8),
2603 (GLdouble) bswap_FLOAT64(pc + 16),
2604 (GLdouble) bswap_FLOAT64(pc + 24),
2605 (GLdouble) bswap_FLOAT64(pc + 32),
2606 (GLdouble) bswap_FLOAT64(pc + 40));
2607 }
2608
2609 void
__glXDispSwap_PopMatrix(GLbyte * pc)2610 __glXDispSwap_PopMatrix(GLbyte * pc)
2611 {
2612 glPopMatrix();
2613 }
2614
2615 void
__glXDispSwap_PushMatrix(GLbyte * pc)2616 __glXDispSwap_PushMatrix(GLbyte * pc)
2617 {
2618 glPushMatrix();
2619 }
2620
2621 void
__glXDispSwap_Rotated(GLbyte * pc)2622 __glXDispSwap_Rotated(GLbyte * pc)
2623 {
2624 #ifdef __GLX_ALIGN64
2625 if ((unsigned long) (pc) & 7) {
2626 (void) memmove(pc - 4, pc, 32);
2627 pc -= 4;
2628 }
2629 #endif
2630
2631 glRotated((GLdouble) bswap_FLOAT64(pc + 0),
2632 (GLdouble) bswap_FLOAT64(pc + 8),
2633 (GLdouble) bswap_FLOAT64(pc + 16),
2634 (GLdouble) bswap_FLOAT64(pc + 24));
2635 }
2636
2637 void
__glXDispSwap_Rotatef(GLbyte * pc)2638 __glXDispSwap_Rotatef(GLbyte * pc)
2639 {
2640 glRotatef((GLfloat) bswap_FLOAT32(pc + 0),
2641 (GLfloat) bswap_FLOAT32(pc + 4),
2642 (GLfloat) bswap_FLOAT32(pc + 8),
2643 (GLfloat) bswap_FLOAT32(pc + 12));
2644 }
2645
2646 void
__glXDispSwap_Scaled(GLbyte * pc)2647 __glXDispSwap_Scaled(GLbyte * pc)
2648 {
2649 #ifdef __GLX_ALIGN64
2650 if ((unsigned long) (pc) & 7) {
2651 (void) memmove(pc - 4, pc, 24);
2652 pc -= 4;
2653 }
2654 #endif
2655
2656 glScaled((GLdouble) bswap_FLOAT64(pc + 0),
2657 (GLdouble) bswap_FLOAT64(pc + 8),
2658 (GLdouble) bswap_FLOAT64(pc + 16));
2659 }
2660
2661 void
__glXDispSwap_Scalef(GLbyte * pc)2662 __glXDispSwap_Scalef(GLbyte * pc)
2663 {
2664 glScalef((GLfloat) bswap_FLOAT32(pc + 0),
2665 (GLfloat) bswap_FLOAT32(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
2666 }
2667
2668 void
__glXDispSwap_Translated(GLbyte * pc)2669 __glXDispSwap_Translated(GLbyte * pc)
2670 {
2671 #ifdef __GLX_ALIGN64
2672 if ((unsigned long) (pc) & 7) {
2673 (void) memmove(pc - 4, pc, 24);
2674 pc -= 4;
2675 }
2676 #endif
2677
2678 glTranslated((GLdouble) bswap_FLOAT64(pc + 0),
2679 (GLdouble) bswap_FLOAT64(pc + 8),
2680 (GLdouble) bswap_FLOAT64(pc + 16));
2681 }
2682
2683 void
__glXDispSwap_Translatef(GLbyte * pc)2684 __glXDispSwap_Translatef(GLbyte * pc)
2685 {
2686 glTranslatef((GLfloat) bswap_FLOAT32(pc + 0),
2687 (GLfloat) bswap_FLOAT32(pc + 4),
2688 (GLfloat) bswap_FLOAT32(pc + 8));
2689 }
2690
2691 void
__glXDispSwap_Viewport(GLbyte * pc)2692 __glXDispSwap_Viewport(GLbyte * pc)
2693 {
2694 glViewport((GLint) bswap_CARD32(pc + 0),
2695 (GLint) bswap_CARD32(pc + 4),
2696 (GLsizei) bswap_CARD32(pc + 8), (GLsizei) bswap_CARD32(pc + 12));
2697 }
2698
2699 void
__glXDispSwap_BindTexture(GLbyte * pc)2700 __glXDispSwap_BindTexture(GLbyte * pc)
2701 {
2702 glBindTexture((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
2703 }
2704
2705 void
__glXDispSwap_Indexubv(GLbyte * pc)2706 __glXDispSwap_Indexubv(GLbyte * pc)
2707 {
2708 glIndexubv((const GLubyte *) (pc + 0));
2709 }
2710
2711 void
__glXDispSwap_PolygonOffset(GLbyte * pc)2712 __glXDispSwap_PolygonOffset(GLbyte * pc)
2713 {
2714 glPolygonOffset((GLfloat) bswap_FLOAT32(pc + 0),
2715 (GLfloat) bswap_FLOAT32(pc + 4));
2716 }
2717
2718 int
__glXDispSwap_AreTexturesResident(__GLXclientState * cl,GLbyte * pc)2719 __glXDispSwap_AreTexturesResident(__GLXclientState * cl, GLbyte * pc)
2720 {
2721 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2722 int error;
2723 __GLXcontext *const cx =
2724 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2725
2726 pc += __GLX_SINGLE_HDR_SIZE;
2727 if (cx != NULL) {
2728 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2729
2730 GLboolean retval;
2731 GLboolean answerBuffer[200];
2732 GLboolean *residences =
2733 __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
2734
2735 if (residences == NULL)
2736 return BadAlloc;
2737 retval =
2738 glAreTexturesResident(n,
2739 (const GLuint *)
2740 bswap_32_array((uint32_t *) (pc + 4), 0),
2741 residences);
2742 __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
2743 error = Success;
2744 }
2745
2746 return error;
2747 }
2748
2749 int
__glXDispSwap_AreTexturesResidentEXT(__GLXclientState * cl,GLbyte * pc)2750 __glXDispSwap_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc)
2751 {
2752 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
2753 int error;
2754 __GLXcontext *const cx =
2755 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2756
2757 pc += __GLX_VENDPRIV_HDR_SIZE;
2758 if (cx != NULL) {
2759 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2760
2761 GLboolean retval;
2762 GLboolean answerBuffer[200];
2763 GLboolean *residences =
2764 __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
2765
2766 if (residences == NULL)
2767 return BadAlloc;
2768 retval =
2769 glAreTexturesResident(n,
2770 (const GLuint *)
2771 bswap_32_array((uint32_t *) (pc + 4), 0),
2772 residences);
2773 __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
2774 error = Success;
2775 }
2776
2777 return error;
2778 }
2779
2780 void
__glXDispSwap_CopyTexImage1D(GLbyte * pc)2781 __glXDispSwap_CopyTexImage1D(GLbyte * pc)
2782 {
2783 glCopyTexImage1D((GLenum) bswap_ENUM(pc + 0),
2784 (GLint) bswap_CARD32(pc + 4),
2785 (GLenum) bswap_ENUM(pc + 8),
2786 (GLint) bswap_CARD32(pc + 12),
2787 (GLint) bswap_CARD32(pc + 16),
2788 (GLsizei) bswap_CARD32(pc + 20),
2789 (GLint) bswap_CARD32(pc + 24));
2790 }
2791
2792 void
__glXDispSwap_CopyTexImage2D(GLbyte * pc)2793 __glXDispSwap_CopyTexImage2D(GLbyte * pc)
2794 {
2795 glCopyTexImage2D((GLenum) bswap_ENUM(pc + 0),
2796 (GLint) bswap_CARD32(pc + 4),
2797 (GLenum) bswap_ENUM(pc + 8),
2798 (GLint) bswap_CARD32(pc + 12),
2799 (GLint) bswap_CARD32(pc + 16),
2800 (GLsizei) bswap_CARD32(pc + 20),
2801 (GLsizei) bswap_CARD32(pc + 24),
2802 (GLint) bswap_CARD32(pc + 28));
2803 }
2804
2805 void
__glXDispSwap_CopyTexSubImage1D(GLbyte * pc)2806 __glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
2807 {
2808 glCopyTexSubImage1D((GLenum) bswap_ENUM(pc + 0),
2809 (GLint) bswap_CARD32(pc + 4),
2810 (GLint) bswap_CARD32(pc + 8),
2811 (GLint) bswap_CARD32(pc + 12),
2812 (GLint) bswap_CARD32(pc + 16),
2813 (GLsizei) bswap_CARD32(pc + 20));
2814 }
2815
2816 void
__glXDispSwap_CopyTexSubImage2D(GLbyte * pc)2817 __glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
2818 {
2819 glCopyTexSubImage2D((GLenum) bswap_ENUM(pc + 0),
2820 (GLint) bswap_CARD32(pc + 4),
2821 (GLint) bswap_CARD32(pc + 8),
2822 (GLint) bswap_CARD32(pc + 12),
2823 (GLint) bswap_CARD32(pc + 16),
2824 (GLint) bswap_CARD32(pc + 20),
2825 (GLsizei) bswap_CARD32(pc + 24),
2826 (GLsizei) bswap_CARD32(pc + 28));
2827 }
2828
2829 int
__glXDispSwap_DeleteTextures(__GLXclientState * cl,GLbyte * pc)2830 __glXDispSwap_DeleteTextures(__GLXclientState * cl, GLbyte * pc)
2831 {
2832 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2833 int error;
2834 __GLXcontext *const cx =
2835 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2836
2837 pc += __GLX_SINGLE_HDR_SIZE;
2838 if (cx != NULL) {
2839 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2840
2841 glDeleteTextures(n,
2842 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
2843 0));
2844 error = Success;
2845 }
2846
2847 return error;
2848 }
2849
2850 int
__glXDispSwap_DeleteTexturesEXT(__GLXclientState * cl,GLbyte * pc)2851 __glXDispSwap_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc)
2852 {
2853 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
2854 int error;
2855 __GLXcontext *const cx =
2856 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2857
2858 pc += __GLX_VENDPRIV_HDR_SIZE;
2859 if (cx != NULL) {
2860 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2861
2862 glDeleteTextures(n,
2863 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
2864 0));
2865 error = Success;
2866 }
2867
2868 return error;
2869 }
2870
2871 int
__glXDispSwap_GenTextures(__GLXclientState * cl,GLbyte * pc)2872 __glXDispSwap_GenTextures(__GLXclientState * cl, GLbyte * pc)
2873 {
2874 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2875 int error;
2876 __GLXcontext *const cx =
2877 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2878
2879 pc += __GLX_SINGLE_HDR_SIZE;
2880 if (cx != NULL) {
2881 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2882
2883 GLuint answerBuffer[200];
2884 GLuint *textures =
2885 __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
2886 4);
2887
2888 if (textures == NULL)
2889 return BadAlloc;
2890 glGenTextures(n, textures);
2891 (void) bswap_32_array((uint32_t *) textures, n);
2892 __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
2893 error = Success;
2894 }
2895
2896 return error;
2897 }
2898
2899 int
__glXDispSwap_GenTexturesEXT(__GLXclientState * cl,GLbyte * pc)2900 __glXDispSwap_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc)
2901 {
2902 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
2903 int error;
2904 __GLXcontext *const cx =
2905 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2906
2907 pc += __GLX_VENDPRIV_HDR_SIZE;
2908 if (cx != NULL) {
2909 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2910
2911 GLuint answerBuffer[200];
2912 GLuint *textures =
2913 __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
2914 4);
2915
2916 if (textures == NULL)
2917 return BadAlloc;
2918 glGenTextures(n, textures);
2919 (void) bswap_32_array((uint32_t *) textures, n);
2920 __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
2921 error = Success;
2922 }
2923
2924 return error;
2925 }
2926
2927 int
__glXDispSwap_IsTexture(__GLXclientState * cl,GLbyte * pc)2928 __glXDispSwap_IsTexture(__GLXclientState * cl, GLbyte * pc)
2929 {
2930 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
2931 int error;
2932 __GLXcontext *const cx =
2933 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2934
2935 pc += __GLX_SINGLE_HDR_SIZE;
2936 if (cx != NULL) {
2937 GLboolean retval;
2938
2939 retval = glIsTexture((GLuint) bswap_CARD32(pc + 0));
2940 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2941 error = Success;
2942 }
2943
2944 return error;
2945 }
2946
2947 int
__glXDispSwap_IsTextureEXT(__GLXclientState * cl,GLbyte * pc)2948 __glXDispSwap_IsTextureEXT(__GLXclientState * cl, GLbyte * pc)
2949 {
2950 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
2951 int error;
2952 __GLXcontext *const cx =
2953 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
2954
2955 pc += __GLX_VENDPRIV_HDR_SIZE;
2956 if (cx != NULL) {
2957 GLboolean retval;
2958
2959 retval = glIsTexture((GLuint) bswap_CARD32(pc + 0));
2960 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
2961 error = Success;
2962 }
2963
2964 return error;
2965 }
2966
2967 void
__glXDispSwap_PrioritizeTextures(GLbyte * pc)2968 __glXDispSwap_PrioritizeTextures(GLbyte * pc)
2969 {
2970 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
2971
2972 glPrioritizeTextures(n,
2973 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
2974 0),
2975 (const GLclampf *)
2976 bswap_32_array((uint32_t *) (pc + 4), 0));
2977 }
2978
2979 void
__glXDispSwap_TexSubImage1D(GLbyte * pc)2980 __glXDispSwap_TexSubImage1D(GLbyte * pc)
2981 {
2982 const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
2983 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
2984
2985 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
2986 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
2987 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
2988 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
2989 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
2990 (GLint) bswap_CARD32(&hdr->skipPixels));
2991 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
2992
2993 glTexSubImage1D((GLenum) bswap_ENUM(pc + 20),
2994 (GLint) bswap_CARD32(pc + 24),
2995 (GLint) bswap_CARD32(pc + 28),
2996 (GLsizei) bswap_CARD32(pc + 36),
2997 (GLenum) bswap_ENUM(pc + 44),
2998 (GLenum) bswap_ENUM(pc + 48), pixels);
2999 }
3000
3001 void
__glXDispSwap_TexSubImage2D(GLbyte * pc)3002 __glXDispSwap_TexSubImage2D(GLbyte * pc)
3003 {
3004 const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
3005 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
3006
3007 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3008 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3009 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3010 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3011 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3012 (GLint) bswap_CARD32(&hdr->skipPixels));
3013 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3014
3015 glTexSubImage2D((GLenum) bswap_ENUM(pc + 20),
3016 (GLint) bswap_CARD32(pc + 24),
3017 (GLint) bswap_CARD32(pc + 28),
3018 (GLint) bswap_CARD32(pc + 32),
3019 (GLsizei) bswap_CARD32(pc + 36),
3020 (GLsizei) bswap_CARD32(pc + 40),
3021 (GLenum) bswap_ENUM(pc + 44),
3022 (GLenum) bswap_ENUM(pc + 48), pixels);
3023 }
3024
3025 void
__glXDispSwap_BlendColor(GLbyte * pc)3026 __glXDispSwap_BlendColor(GLbyte * pc)
3027 {
3028 glBlendColor((GLclampf) bswap_FLOAT32(pc + 0),
3029 (GLclampf) bswap_FLOAT32(pc + 4),
3030 (GLclampf) bswap_FLOAT32(pc + 8),
3031 (GLclampf) bswap_FLOAT32(pc + 12));
3032 }
3033
3034 void
__glXDispSwap_BlendEquation(GLbyte * pc)3035 __glXDispSwap_BlendEquation(GLbyte * pc)
3036 {
3037 glBlendEquation((GLenum) bswap_ENUM(pc + 0));
3038 }
3039
3040 void
__glXDispSwap_ColorTable(GLbyte * pc)3041 __glXDispSwap_ColorTable(GLbyte * pc)
3042 {
3043 const GLvoid *const table = (const GLvoid *) ((pc + 40));
3044 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
3045
3046 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3047 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3048 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3049 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3050 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3051 (GLint) bswap_CARD32(&hdr->skipPixels));
3052 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3053
3054 glColorTable((GLenum) bswap_ENUM(pc + 20),
3055 (GLenum) bswap_ENUM(pc + 24),
3056 (GLsizei) bswap_CARD32(pc + 28),
3057 (GLenum) bswap_ENUM(pc + 32),
3058 (GLenum) bswap_ENUM(pc + 36), table);
3059 }
3060
3061 void
__glXDispSwap_ColorTableParameterfv(GLbyte * pc)3062 __glXDispSwap_ColorTableParameterfv(GLbyte * pc)
3063 {
3064 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3065 const GLfloat *params;
3066
3067 params =
3068 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
3069 __glColorTableParameterfv_size(pname));
3070
3071 glColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3072 }
3073
3074 void
__glXDispSwap_ColorTableParameteriv(GLbyte * pc)3075 __glXDispSwap_ColorTableParameteriv(GLbyte * pc)
3076 {
3077 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3078 const GLint *params;
3079
3080 params =
3081 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
3082 __glColorTableParameteriv_size(pname));
3083
3084 glColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3085 }
3086
3087 void
__glXDispSwap_CopyColorTable(GLbyte * pc)3088 __glXDispSwap_CopyColorTable(GLbyte * pc)
3089 {
3090 glCopyColorTable((GLenum) bswap_ENUM(pc + 0),
3091 (GLenum) bswap_ENUM(pc + 4),
3092 (GLint) bswap_CARD32(pc + 8),
3093 (GLint) bswap_CARD32(pc + 12),
3094 (GLsizei) bswap_CARD32(pc + 16));
3095 }
3096
3097 int
__glXDispSwap_GetColorTableParameterfv(__GLXclientState * cl,GLbyte * pc)3098 __glXDispSwap_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc)
3099 {
3100 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3101 int error;
3102 __GLXcontext *const cx =
3103 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3104
3105 pc += __GLX_SINGLE_HDR_SIZE;
3106 if (cx != NULL) {
3107 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3108
3109 const GLuint compsize = __glGetColorTableParameterfv_size(pname);
3110 GLfloat answerBuffer[200];
3111 GLfloat *params =
3112 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3113 sizeof(answerBuffer), 4);
3114
3115 if (params == NULL)
3116 return BadAlloc;
3117 __glXClearErrorOccured();
3118
3119 glGetColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3120 (void) bswap_32_array((uint32_t *) params, compsize);
3121 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3122 error = Success;
3123 }
3124
3125 return error;
3126 }
3127
3128 int
__glXDispSwap_GetColorTableParameterfvSGI(__GLXclientState * cl,GLbyte * pc)3129 __glXDispSwap_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc)
3130 {
3131 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3132 int error;
3133 __GLXcontext *const cx =
3134 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3135
3136 pc += __GLX_VENDPRIV_HDR_SIZE;
3137 if (cx != NULL) {
3138 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3139
3140 const GLuint compsize = __glGetColorTableParameterfv_size(pname);
3141 GLfloat answerBuffer[200];
3142 GLfloat *params =
3143 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3144 sizeof(answerBuffer), 4);
3145
3146 if (params == NULL)
3147 return BadAlloc;
3148 __glXClearErrorOccured();
3149
3150 glGetColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3151 (void) bswap_32_array((uint32_t *) params, compsize);
3152 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3153 error = Success;
3154 }
3155
3156 return error;
3157 }
3158
3159 int
__glXDispSwap_GetColorTableParameteriv(__GLXclientState * cl,GLbyte * pc)3160 __glXDispSwap_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc)
3161 {
3162 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3163 int error;
3164 __GLXcontext *const cx =
3165 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3166
3167 pc += __GLX_SINGLE_HDR_SIZE;
3168 if (cx != NULL) {
3169 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3170
3171 const GLuint compsize = __glGetColorTableParameteriv_size(pname);
3172 GLint answerBuffer[200];
3173 GLint *params =
3174 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3175 sizeof(answerBuffer), 4);
3176
3177 if (params == NULL)
3178 return BadAlloc;
3179 __glXClearErrorOccured();
3180
3181 glGetColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3182 (void) bswap_32_array((uint32_t *) params, compsize);
3183 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3184 error = Success;
3185 }
3186
3187 return error;
3188 }
3189
3190 int
__glXDispSwap_GetColorTableParameterivSGI(__GLXclientState * cl,GLbyte * pc)3191 __glXDispSwap_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc)
3192 {
3193 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3194 int error;
3195 __GLXcontext *const cx =
3196 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3197
3198 pc += __GLX_VENDPRIV_HDR_SIZE;
3199 if (cx != NULL) {
3200 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3201
3202 const GLuint compsize = __glGetColorTableParameteriv_size(pname);
3203 GLint answerBuffer[200];
3204 GLint *params =
3205 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3206 sizeof(answerBuffer), 4);
3207
3208 if (params == NULL)
3209 return BadAlloc;
3210 __glXClearErrorOccured();
3211
3212 glGetColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3213 (void) bswap_32_array((uint32_t *) params, compsize);
3214 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3215 error = Success;
3216 }
3217
3218 return error;
3219 }
3220
3221 void
__glXDispSwap_ColorSubTable(GLbyte * pc)3222 __glXDispSwap_ColorSubTable(GLbyte * pc)
3223 {
3224 const GLvoid *const data = (const GLvoid *) ((pc + 40));
3225 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
3226
3227 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3228 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3229 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3230 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3231 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3232 (GLint) bswap_CARD32(&hdr->skipPixels));
3233 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3234
3235 glColorSubTable((GLenum) bswap_ENUM(pc + 20),
3236 (GLsizei) bswap_CARD32(pc + 24),
3237 (GLsizei) bswap_CARD32(pc + 28),
3238 (GLenum) bswap_ENUM(pc + 32),
3239 (GLenum) bswap_ENUM(pc + 36), data);
3240 }
3241
3242 void
__glXDispSwap_CopyColorSubTable(GLbyte * pc)3243 __glXDispSwap_CopyColorSubTable(GLbyte * pc)
3244 {
3245 glCopyColorSubTable((GLenum) bswap_ENUM(pc + 0),
3246 (GLsizei) bswap_CARD32(pc + 4),
3247 (GLint) bswap_CARD32(pc + 8),
3248 (GLint) bswap_CARD32(pc + 12),
3249 (GLsizei) bswap_CARD32(pc + 16));
3250 }
3251
3252 void
__glXDispSwap_ConvolutionFilter1D(GLbyte * pc)3253 __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
3254 {
3255 const GLvoid *const image = (const GLvoid *) ((pc + 44));
3256 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
3257
3258 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3259 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3260 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3261 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3262 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3263 (GLint) bswap_CARD32(&hdr->skipPixels));
3264 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3265
3266 glConvolutionFilter1D((GLenum) bswap_ENUM(pc + 20),
3267 (GLenum) bswap_ENUM(pc + 24),
3268 (GLsizei) bswap_CARD32(pc + 28),
3269 (GLenum) bswap_ENUM(pc + 36),
3270 (GLenum) bswap_ENUM(pc + 40), image);
3271 }
3272
3273 void
__glXDispSwap_ConvolutionFilter2D(GLbyte * pc)3274 __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
3275 {
3276 const GLvoid *const image = (const GLvoid *) ((pc + 44));
3277 __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
3278
3279 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3280 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3281 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3282 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3283 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3284 (GLint) bswap_CARD32(&hdr->skipPixels));
3285 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3286
3287 glConvolutionFilter2D((GLenum) bswap_ENUM(pc + 20),
3288 (GLenum) bswap_ENUM(pc + 24),
3289 (GLsizei) bswap_CARD32(pc + 28),
3290 (GLsizei) bswap_CARD32(pc + 32),
3291 (GLenum) bswap_ENUM(pc + 36),
3292 (GLenum) bswap_ENUM(pc + 40), image);
3293 }
3294
3295 void
__glXDispSwap_ConvolutionParameterf(GLbyte * pc)3296 __glXDispSwap_ConvolutionParameterf(GLbyte * pc)
3297 {
3298 glConvolutionParameterf((GLenum) bswap_ENUM(pc + 0),
3299 (GLenum) bswap_ENUM(pc + 4),
3300 (GLfloat) bswap_FLOAT32(pc + 8));
3301 }
3302
3303 void
__glXDispSwap_ConvolutionParameterfv(GLbyte * pc)3304 __glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
3305 {
3306 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3307 const GLfloat *params;
3308
3309 params =
3310 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
3311 __glConvolutionParameterfv_size
3312 (pname));
3313
3314 glConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3315 }
3316
3317 void
__glXDispSwap_ConvolutionParameteri(GLbyte * pc)3318 __glXDispSwap_ConvolutionParameteri(GLbyte * pc)
3319 {
3320 glConvolutionParameteri((GLenum) bswap_ENUM(pc + 0),
3321 (GLenum) bswap_ENUM(pc + 4),
3322 (GLint) bswap_CARD32(pc + 8));
3323 }
3324
3325 void
__glXDispSwap_ConvolutionParameteriv(GLbyte * pc)3326 __glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
3327 {
3328 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3329 const GLint *params;
3330
3331 params =
3332 (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
3333 __glConvolutionParameteriv_size(pname));
3334
3335 glConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3336 }
3337
3338 void
__glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)3339 __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
3340 {
3341 glCopyConvolutionFilter1D((GLenum) bswap_ENUM(pc + 0),
3342 (GLenum) bswap_ENUM(pc + 4),
3343 (GLint) bswap_CARD32(pc + 8),
3344 (GLint) bswap_CARD32(pc + 12),
3345 (GLsizei) bswap_CARD32(pc + 16));
3346 }
3347
3348 void
__glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)3349 __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
3350 {
3351 glCopyConvolutionFilter2D((GLenum) bswap_ENUM(pc + 0),
3352 (GLenum) bswap_ENUM(pc + 4),
3353 (GLint) bswap_CARD32(pc + 8),
3354 (GLint) bswap_CARD32(pc + 12),
3355 (GLsizei) bswap_CARD32(pc + 16),
3356 (GLsizei) bswap_CARD32(pc + 20));
3357 }
3358
3359 int
__glXDispSwap_GetConvolutionParameterfv(__GLXclientState * cl,GLbyte * pc)3360 __glXDispSwap_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc)
3361 {
3362 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3363 int error;
3364 __GLXcontext *const cx =
3365 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3366
3367 pc += __GLX_SINGLE_HDR_SIZE;
3368 if (cx != NULL) {
3369 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3370
3371 const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
3372 GLfloat answerBuffer[200];
3373 GLfloat *params =
3374 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3375 sizeof(answerBuffer), 4);
3376
3377 if (params == NULL)
3378 return BadAlloc;
3379 __glXClearErrorOccured();
3380
3381 glGetConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3382 (void) bswap_32_array((uint32_t *) params, compsize);
3383 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3384 error = Success;
3385 }
3386
3387 return error;
3388 }
3389
3390 int
__glXDispSwap_GetConvolutionParameterfvEXT(__GLXclientState * cl,GLbyte * pc)3391 __glXDispSwap_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
3392 {
3393 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3394 int error;
3395 __GLXcontext *const cx =
3396 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3397
3398 pc += __GLX_VENDPRIV_HDR_SIZE;
3399 if (cx != NULL) {
3400 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3401
3402 const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
3403 GLfloat answerBuffer[200];
3404 GLfloat *params =
3405 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3406 sizeof(answerBuffer), 4);
3407
3408 if (params == NULL)
3409 return BadAlloc;
3410 __glXClearErrorOccured();
3411
3412 glGetConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3413 (void) bswap_32_array((uint32_t *) params, compsize);
3414 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3415 error = Success;
3416 }
3417
3418 return error;
3419 }
3420
3421 int
__glXDispSwap_GetConvolutionParameteriv(__GLXclientState * cl,GLbyte * pc)3422 __glXDispSwap_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc)
3423 {
3424 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3425 int error;
3426 __GLXcontext *const cx =
3427 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3428
3429 pc += __GLX_SINGLE_HDR_SIZE;
3430 if (cx != NULL) {
3431 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3432
3433 const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
3434 GLint answerBuffer[200];
3435 GLint *params =
3436 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3437 sizeof(answerBuffer), 4);
3438
3439 if (params == NULL)
3440 return BadAlloc;
3441 __glXClearErrorOccured();
3442
3443 glGetConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3444 (void) bswap_32_array((uint32_t *) params, compsize);
3445 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3446 error = Success;
3447 }
3448
3449 return error;
3450 }
3451
3452 int
__glXDispSwap_GetConvolutionParameterivEXT(__GLXclientState * cl,GLbyte * pc)3453 __glXDispSwap_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc)
3454 {
3455 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3456 int error;
3457 __GLXcontext *const cx =
3458 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3459
3460 pc += __GLX_VENDPRIV_HDR_SIZE;
3461 if (cx != NULL) {
3462 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3463
3464 const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
3465 GLint answerBuffer[200];
3466 GLint *params =
3467 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3468 sizeof(answerBuffer), 4);
3469
3470 if (params == NULL)
3471 return BadAlloc;
3472 __glXClearErrorOccured();
3473
3474 glGetConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3475 (void) bswap_32_array((uint32_t *) params, compsize);
3476 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3477 error = Success;
3478 }
3479
3480 return error;
3481 }
3482
3483 int
__glXDispSwap_GetHistogramParameterfv(__GLXclientState * cl,GLbyte * pc)3484 __glXDispSwap_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc)
3485 {
3486 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3487 int error;
3488 __GLXcontext *const cx =
3489 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3490
3491 pc += __GLX_SINGLE_HDR_SIZE;
3492 if (cx != NULL) {
3493 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3494
3495 const GLuint compsize = __glGetHistogramParameterfv_size(pname);
3496 GLfloat answerBuffer[200];
3497 GLfloat *params =
3498 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3499 sizeof(answerBuffer), 4);
3500
3501 if (params == NULL)
3502 return BadAlloc;
3503 __glXClearErrorOccured();
3504
3505 glGetHistogramParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3506 (void) bswap_32_array((uint32_t *) params, compsize);
3507 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3508 error = Success;
3509 }
3510
3511 return error;
3512 }
3513
3514 int
__glXDispSwap_GetHistogramParameterfvEXT(__GLXclientState * cl,GLbyte * pc)3515 __glXDispSwap_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
3516 {
3517 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3518 int error;
3519 __GLXcontext *const cx =
3520 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3521
3522 pc += __GLX_VENDPRIV_HDR_SIZE;
3523 if (cx != NULL) {
3524 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3525
3526 const GLuint compsize = __glGetHistogramParameterfv_size(pname);
3527 GLfloat answerBuffer[200];
3528 GLfloat *params =
3529 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3530 sizeof(answerBuffer), 4);
3531
3532 if (params == NULL)
3533 return BadAlloc;
3534 __glXClearErrorOccured();
3535
3536 glGetHistogramParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3537 (void) bswap_32_array((uint32_t *) params, compsize);
3538 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3539 error = Success;
3540 }
3541
3542 return error;
3543 }
3544
3545 int
__glXDispSwap_GetHistogramParameteriv(__GLXclientState * cl,GLbyte * pc)3546 __glXDispSwap_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc)
3547 {
3548 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3549 int error;
3550 __GLXcontext *const cx =
3551 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3552
3553 pc += __GLX_SINGLE_HDR_SIZE;
3554 if (cx != NULL) {
3555 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3556
3557 const GLuint compsize = __glGetHistogramParameteriv_size(pname);
3558 GLint answerBuffer[200];
3559 GLint *params =
3560 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3561 sizeof(answerBuffer), 4);
3562
3563 if (params == NULL)
3564 return BadAlloc;
3565 __glXClearErrorOccured();
3566
3567 glGetHistogramParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3568 (void) bswap_32_array((uint32_t *) params, compsize);
3569 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3570 error = Success;
3571 }
3572
3573 return error;
3574 }
3575
3576 int
__glXDispSwap_GetHistogramParameterivEXT(__GLXclientState * cl,GLbyte * pc)3577 __glXDispSwap_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc)
3578 {
3579 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3580 int error;
3581 __GLXcontext *const cx =
3582 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3583
3584 pc += __GLX_VENDPRIV_HDR_SIZE;
3585 if (cx != NULL) {
3586 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3587
3588 const GLuint compsize = __glGetHistogramParameteriv_size(pname);
3589 GLint answerBuffer[200];
3590 GLint *params =
3591 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3592 sizeof(answerBuffer), 4);
3593
3594 if (params == NULL)
3595 return BadAlloc;
3596 __glXClearErrorOccured();
3597
3598 glGetHistogramParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3599 (void) bswap_32_array((uint32_t *) params, compsize);
3600 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3601 error = Success;
3602 }
3603
3604 return error;
3605 }
3606
3607 int
__glXDispSwap_GetMinmaxParameterfv(__GLXclientState * cl,GLbyte * pc)3608 __glXDispSwap_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc)
3609 {
3610 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3611 int error;
3612 __GLXcontext *const cx =
3613 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3614
3615 pc += __GLX_SINGLE_HDR_SIZE;
3616 if (cx != NULL) {
3617 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3618
3619 const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
3620 GLfloat answerBuffer[200];
3621 GLfloat *params =
3622 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3623 sizeof(answerBuffer), 4);
3624
3625 if (params == NULL)
3626 return BadAlloc;
3627 __glXClearErrorOccured();
3628
3629 glGetMinmaxParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3630 (void) bswap_32_array((uint32_t *) params, compsize);
3631 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3632 error = Success;
3633 }
3634
3635 return error;
3636 }
3637
3638 int
__glXDispSwap_GetMinmaxParameterfvEXT(__GLXclientState * cl,GLbyte * pc)3639 __glXDispSwap_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
3640 {
3641 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3642 int error;
3643 __GLXcontext *const cx =
3644 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3645
3646 pc += __GLX_VENDPRIV_HDR_SIZE;
3647 if (cx != NULL) {
3648 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3649
3650 const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
3651 GLfloat answerBuffer[200];
3652 GLfloat *params =
3653 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3654 sizeof(answerBuffer), 4);
3655
3656 if (params == NULL)
3657 return BadAlloc;
3658 __glXClearErrorOccured();
3659
3660 glGetMinmaxParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
3661 (void) bswap_32_array((uint32_t *) params, compsize);
3662 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3663 error = Success;
3664 }
3665
3666 return error;
3667 }
3668
3669 int
__glXDispSwap_GetMinmaxParameteriv(__GLXclientState * cl,GLbyte * pc)3670 __glXDispSwap_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc)
3671 {
3672 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
3673 int error;
3674 __GLXcontext *const cx =
3675 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3676
3677 pc += __GLX_SINGLE_HDR_SIZE;
3678 if (cx != NULL) {
3679 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3680
3681 const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
3682 GLint answerBuffer[200];
3683 GLint *params =
3684 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3685 sizeof(answerBuffer), 4);
3686
3687 if (params == NULL)
3688 return BadAlloc;
3689 __glXClearErrorOccured();
3690
3691 glGetMinmaxParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3692 (void) bswap_32_array((uint32_t *) params, compsize);
3693 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3694 error = Success;
3695 }
3696
3697 return error;
3698 }
3699
3700 int
__glXDispSwap_GetMinmaxParameterivEXT(__GLXclientState * cl,GLbyte * pc)3701 __glXDispSwap_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc)
3702 {
3703 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
3704 int error;
3705 __GLXcontext *const cx =
3706 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
3707
3708 pc += __GLX_VENDPRIV_HDR_SIZE;
3709 if (cx != NULL) {
3710 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
3711
3712 const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
3713 GLint answerBuffer[200];
3714 GLint *params =
3715 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
3716 sizeof(answerBuffer), 4);
3717
3718 if (params == NULL)
3719 return BadAlloc;
3720 __glXClearErrorOccured();
3721
3722 glGetMinmaxParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
3723 (void) bswap_32_array((uint32_t *) params, compsize);
3724 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
3725 error = Success;
3726 }
3727
3728 return error;
3729 }
3730
3731 void
__glXDispSwap_Histogram(GLbyte * pc)3732 __glXDispSwap_Histogram(GLbyte * pc)
3733 {
3734 glHistogram((GLenum) bswap_ENUM(pc + 0),
3735 (GLsizei) bswap_CARD32(pc + 4),
3736 (GLenum) bswap_ENUM(pc + 8), *(GLboolean *) (pc + 12));
3737 }
3738
3739 void
__glXDispSwap_Minmax(GLbyte * pc)3740 __glXDispSwap_Minmax(GLbyte * pc)
3741 {
3742 glMinmax((GLenum) bswap_ENUM(pc + 0),
3743 (GLenum) bswap_ENUM(pc + 4), *(GLboolean *) (pc + 8));
3744 }
3745
3746 void
__glXDispSwap_ResetHistogram(GLbyte * pc)3747 __glXDispSwap_ResetHistogram(GLbyte * pc)
3748 {
3749 glResetHistogram((GLenum) bswap_ENUM(pc + 0));
3750 }
3751
3752 void
__glXDispSwap_ResetMinmax(GLbyte * pc)3753 __glXDispSwap_ResetMinmax(GLbyte * pc)
3754 {
3755 glResetMinmax((GLenum) bswap_ENUM(pc + 0));
3756 }
3757
3758 void
__glXDispSwap_TexImage3D(GLbyte * pc)3759 __glXDispSwap_TexImage3D(GLbyte * pc)
3760 {
3761 const CARD32 ptr_is_null = *(CARD32 *) (pc + 76);
3762 const GLvoid *const pixels =
3763 (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
3764 __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
3765
3766 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3767 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3768 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3769 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT,
3770 (GLint) bswap_CARD32(&hdr->imageHeight));
3771 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3772 glPixelStorei(GL_UNPACK_SKIP_IMAGES,
3773 (GLint) bswap_CARD32(&hdr->skipImages));
3774 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3775 (GLint) bswap_CARD32(&hdr->skipPixels));
3776 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3777
3778 glTexImage3D((GLenum) bswap_ENUM(pc + 36),
3779 (GLint) bswap_CARD32(pc + 40),
3780 (GLint) bswap_CARD32(pc + 44),
3781 (GLsizei) bswap_CARD32(pc + 48),
3782 (GLsizei) bswap_CARD32(pc + 52),
3783 (GLsizei) bswap_CARD32(pc + 56),
3784 (GLint) bswap_CARD32(pc + 64),
3785 (GLenum) bswap_ENUM(pc + 68),
3786 (GLenum) bswap_ENUM(pc + 72), pixels);
3787 }
3788
3789 void
__glXDispSwap_TexSubImage3D(GLbyte * pc)3790 __glXDispSwap_TexSubImage3D(GLbyte * pc)
3791 {
3792 const GLvoid *const pixels = (const GLvoid *) ((pc + 88));
3793 __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
3794
3795 glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
3796 glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
3797 glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
3798 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT,
3799 (GLint) bswap_CARD32(&hdr->imageHeight));
3800 glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
3801 glPixelStorei(GL_UNPACK_SKIP_IMAGES,
3802 (GLint) bswap_CARD32(&hdr->skipImages));
3803 glPixelStorei(GL_UNPACK_SKIP_PIXELS,
3804 (GLint) bswap_CARD32(&hdr->skipPixels));
3805 glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
3806
3807 glTexSubImage3D((GLenum) bswap_ENUM(pc + 36),
3808 (GLint) bswap_CARD32(pc + 40),
3809 (GLint) bswap_CARD32(pc + 44),
3810 (GLint) bswap_CARD32(pc + 48),
3811 (GLint) bswap_CARD32(pc + 52),
3812 (GLsizei) bswap_CARD32(pc + 60),
3813 (GLsizei) bswap_CARD32(pc + 64),
3814 (GLsizei) bswap_CARD32(pc + 68),
3815 (GLenum) bswap_ENUM(pc + 76),
3816 (GLenum) bswap_ENUM(pc + 80), pixels);
3817 }
3818
3819 void
__glXDispSwap_CopyTexSubImage3D(GLbyte * pc)3820 __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
3821 {
3822 glCopyTexSubImage3D((GLenum) bswap_ENUM(pc + 0),
3823 (GLint) bswap_CARD32(pc + 4),
3824 (GLint) bswap_CARD32(pc + 8),
3825 (GLint) bswap_CARD32(pc + 12),
3826 (GLint) bswap_CARD32(pc + 16),
3827 (GLint) bswap_CARD32(pc + 20),
3828 (GLint) bswap_CARD32(pc + 24),
3829 (GLsizei) bswap_CARD32(pc + 28),
3830 (GLsizei) bswap_CARD32(pc + 32));
3831 }
3832
3833 void
__glXDispSwap_ActiveTexture(GLbyte * pc)3834 __glXDispSwap_ActiveTexture(GLbyte * pc)
3835 {
3836 glActiveTextureARB((GLenum) bswap_ENUM(pc + 0));
3837 }
3838
3839 void
__glXDispSwap_MultiTexCoord1dv(GLbyte * pc)3840 __glXDispSwap_MultiTexCoord1dv(GLbyte * pc)
3841 {
3842 #ifdef __GLX_ALIGN64
3843 if ((unsigned long) (pc) & 7) {
3844 (void) memmove(pc - 4, pc, 12);
3845 pc -= 4;
3846 }
3847 #endif
3848
3849 glMultiTexCoord1dvARB((GLenum) bswap_ENUM(pc + 8),
3850 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
3851 1));
3852 }
3853
3854 void
__glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)3855 __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
3856 {
3857 glMultiTexCoord1fvARB((GLenum) bswap_ENUM(pc + 0),
3858 (const GLfloat *)
3859 bswap_32_array((uint32_t *) (pc + 4), 1));
3860 }
3861
3862 void
__glXDispSwap_MultiTexCoord1iv(GLbyte * pc)3863 __glXDispSwap_MultiTexCoord1iv(GLbyte * pc)
3864 {
3865 glMultiTexCoord1ivARB((GLenum) bswap_ENUM(pc + 0),
3866 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
3867 1));
3868 }
3869
3870 void
__glXDispSwap_MultiTexCoord1sv(GLbyte * pc)3871 __glXDispSwap_MultiTexCoord1sv(GLbyte * pc)
3872 {
3873 glMultiTexCoord1svARB((GLenum) bswap_ENUM(pc + 0),
3874 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
3875 1));
3876 }
3877
3878 void
__glXDispSwap_MultiTexCoord2dv(GLbyte * pc)3879 __glXDispSwap_MultiTexCoord2dv(GLbyte * pc)
3880 {
3881 #ifdef __GLX_ALIGN64
3882 if ((unsigned long) (pc) & 7) {
3883 (void) memmove(pc - 4, pc, 20);
3884 pc -= 4;
3885 }
3886 #endif
3887
3888 glMultiTexCoord2dvARB((GLenum) bswap_ENUM(pc + 16),
3889 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
3890 2));
3891 }
3892
3893 void
__glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)3894 __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
3895 {
3896 glMultiTexCoord2fvARB((GLenum) bswap_ENUM(pc + 0),
3897 (const GLfloat *)
3898 bswap_32_array((uint32_t *) (pc + 4), 2));
3899 }
3900
3901 void
__glXDispSwap_MultiTexCoord2iv(GLbyte * pc)3902 __glXDispSwap_MultiTexCoord2iv(GLbyte * pc)
3903 {
3904 glMultiTexCoord2ivARB((GLenum) bswap_ENUM(pc + 0),
3905 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
3906 2));
3907 }
3908
3909 void
__glXDispSwap_MultiTexCoord2sv(GLbyte * pc)3910 __glXDispSwap_MultiTexCoord2sv(GLbyte * pc)
3911 {
3912 glMultiTexCoord2svARB((GLenum) bswap_ENUM(pc + 0),
3913 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
3914 2));
3915 }
3916
3917 void
__glXDispSwap_MultiTexCoord3dv(GLbyte * pc)3918 __glXDispSwap_MultiTexCoord3dv(GLbyte * pc)
3919 {
3920 #ifdef __GLX_ALIGN64
3921 if ((unsigned long) (pc) & 7) {
3922 (void) memmove(pc - 4, pc, 28);
3923 pc -= 4;
3924 }
3925 #endif
3926
3927 glMultiTexCoord3dvARB((GLenum) bswap_ENUM(pc + 24),
3928 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
3929 3));
3930 }
3931
3932 void
__glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)3933 __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
3934 {
3935 glMultiTexCoord3fvARB((GLenum) bswap_ENUM(pc + 0),
3936 (const GLfloat *)
3937 bswap_32_array((uint32_t *) (pc + 4), 3));
3938 }
3939
3940 void
__glXDispSwap_MultiTexCoord3iv(GLbyte * pc)3941 __glXDispSwap_MultiTexCoord3iv(GLbyte * pc)
3942 {
3943 glMultiTexCoord3ivARB((GLenum) bswap_ENUM(pc + 0),
3944 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
3945 3));
3946 }
3947
3948 void
__glXDispSwap_MultiTexCoord3sv(GLbyte * pc)3949 __glXDispSwap_MultiTexCoord3sv(GLbyte * pc)
3950 {
3951 glMultiTexCoord3svARB((GLenum) bswap_ENUM(pc + 0),
3952 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
3953 3));
3954 }
3955
3956 void
__glXDispSwap_MultiTexCoord4dv(GLbyte * pc)3957 __glXDispSwap_MultiTexCoord4dv(GLbyte * pc)
3958 {
3959 #ifdef __GLX_ALIGN64
3960 if ((unsigned long) (pc) & 7) {
3961 (void) memmove(pc - 4, pc, 36);
3962 pc -= 4;
3963 }
3964 #endif
3965
3966 glMultiTexCoord4dvARB((GLenum) bswap_ENUM(pc + 32),
3967 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
3968 4));
3969 }
3970
3971 void
__glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)3972 __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
3973 {
3974 glMultiTexCoord4fvARB((GLenum) bswap_ENUM(pc + 0),
3975 (const GLfloat *)
3976 bswap_32_array((uint32_t *) (pc + 4), 4));
3977 }
3978
3979 void
__glXDispSwap_MultiTexCoord4iv(GLbyte * pc)3980 __glXDispSwap_MultiTexCoord4iv(GLbyte * pc)
3981 {
3982 glMultiTexCoord4ivARB((GLenum) bswap_ENUM(pc + 0),
3983 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
3984 4));
3985 }
3986
3987 void
__glXDispSwap_MultiTexCoord4sv(GLbyte * pc)3988 __glXDispSwap_MultiTexCoord4sv(GLbyte * pc)
3989 {
3990 glMultiTexCoord4svARB((GLenum) bswap_ENUM(pc + 0),
3991 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
3992 4));
3993 }
3994
3995 void
__glXDispSwap_CompressedTexImage1D(GLbyte * pc)3996 __glXDispSwap_CompressedTexImage1D(GLbyte * pc)
3997 {
3998 PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D =
3999 __glGetProcAddress("glCompressedTexImage1D");
4000 const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20);
4001
4002 CompressedTexImage1D((GLenum) bswap_ENUM(pc + 0),
4003 (GLint) bswap_CARD32(pc + 4),
4004 (GLenum) bswap_ENUM(pc + 8),
4005 (GLsizei) bswap_CARD32(pc + 12),
4006 (GLint) bswap_CARD32(pc + 16),
4007 imageSize, (const GLvoid *) (pc + 24));
4008 }
4009
4010 void
__glXDispSwap_CompressedTexImage2D(GLbyte * pc)4011 __glXDispSwap_CompressedTexImage2D(GLbyte * pc)
4012 {
4013 PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D =
4014 __glGetProcAddress("glCompressedTexImage2D");
4015 const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 24);
4016
4017 CompressedTexImage2D((GLenum) bswap_ENUM(pc + 0),
4018 (GLint) bswap_CARD32(pc + 4),
4019 (GLenum) bswap_ENUM(pc + 8),
4020 (GLsizei) bswap_CARD32(pc + 12),
4021 (GLsizei) bswap_CARD32(pc + 16),
4022 (GLint) bswap_CARD32(pc + 20),
4023 imageSize, (const GLvoid *) (pc + 28));
4024 }
4025
4026 void
__glXDispSwap_CompressedTexImage3D(GLbyte * pc)4027 __glXDispSwap_CompressedTexImage3D(GLbyte * pc)
4028 {
4029 PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D =
4030 __glGetProcAddress("glCompressedTexImage3D");
4031 const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28);
4032
4033 CompressedTexImage3D((GLenum) bswap_ENUM(pc + 0),
4034 (GLint) bswap_CARD32(pc + 4),
4035 (GLenum) bswap_ENUM(pc + 8),
4036 (GLsizei) bswap_CARD32(pc + 12),
4037 (GLsizei) bswap_CARD32(pc + 16),
4038 (GLsizei) bswap_CARD32(pc + 20),
4039 (GLint) bswap_CARD32(pc + 24),
4040 imageSize, (const GLvoid *) (pc + 32));
4041 }
4042
4043 void
__glXDispSwap_CompressedTexSubImage1D(GLbyte * pc)4044 __glXDispSwap_CompressedTexSubImage1D(GLbyte * pc)
4045 {
4046 PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D =
4047 __glGetProcAddress("glCompressedTexSubImage1D");
4048 const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20);
4049
4050 CompressedTexSubImage1D((GLenum) bswap_ENUM(pc + 0),
4051 (GLint) bswap_CARD32(pc + 4),
4052 (GLint) bswap_CARD32(pc + 8),
4053 (GLsizei) bswap_CARD32(pc + 12),
4054 (GLenum) bswap_ENUM(pc + 16),
4055 imageSize, (const GLvoid *) (pc + 24));
4056 }
4057
4058 void
__glXDispSwap_CompressedTexSubImage2D(GLbyte * pc)4059 __glXDispSwap_CompressedTexSubImage2D(GLbyte * pc)
4060 {
4061 PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D =
4062 __glGetProcAddress("glCompressedTexSubImage2D");
4063 const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28);
4064
4065 CompressedTexSubImage2D((GLenum) bswap_ENUM(pc + 0),
4066 (GLint) bswap_CARD32(pc + 4),
4067 (GLint) bswap_CARD32(pc + 8),
4068 (GLint) bswap_CARD32(pc + 12),
4069 (GLsizei) bswap_CARD32(pc + 16),
4070 (GLsizei) bswap_CARD32(pc + 20),
4071 (GLenum) bswap_ENUM(pc + 24),
4072 imageSize, (const GLvoid *) (pc + 32));
4073 }
4074
4075 void
__glXDispSwap_CompressedTexSubImage3D(GLbyte * pc)4076 __glXDispSwap_CompressedTexSubImage3D(GLbyte * pc)
4077 {
4078 PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D =
4079 __glGetProcAddress("glCompressedTexSubImage3D");
4080 const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 36);
4081
4082 CompressedTexSubImage3D((GLenum) bswap_ENUM(pc + 0),
4083 (GLint) bswap_CARD32(pc + 4),
4084 (GLint) bswap_CARD32(pc + 8),
4085 (GLint) bswap_CARD32(pc + 12),
4086 (GLint) bswap_CARD32(pc + 16),
4087 (GLsizei) bswap_CARD32(pc + 20),
4088 (GLsizei) bswap_CARD32(pc + 24),
4089 (GLsizei) bswap_CARD32(pc + 28),
4090 (GLenum) bswap_ENUM(pc + 32),
4091 imageSize, (const GLvoid *) (pc + 40));
4092 }
4093
4094 void
__glXDispSwap_SampleCoverage(GLbyte * pc)4095 __glXDispSwap_SampleCoverage(GLbyte * pc)
4096 {
4097 PFNGLSAMPLECOVERAGEPROC SampleCoverage =
4098 __glGetProcAddress("glSampleCoverage");
4099 SampleCoverage((GLclampf) bswap_FLOAT32(pc + 0), *(GLboolean *) (pc + 4));
4100 }
4101
4102 void
__glXDispSwap_BlendFuncSeparate(GLbyte * pc)4103 __glXDispSwap_BlendFuncSeparate(GLbyte * pc)
4104 {
4105 PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate =
4106 __glGetProcAddress("glBlendFuncSeparate");
4107 BlendFuncSeparate((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4),
4108 (GLenum) bswap_ENUM(pc + 8),
4109 (GLenum) bswap_ENUM(pc + 12));
4110 }
4111
4112 void
__glXDispSwap_FogCoorddv(GLbyte * pc)4113 __glXDispSwap_FogCoorddv(GLbyte * pc)
4114 {
4115 PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
4116
4117 #ifdef __GLX_ALIGN64
4118 if ((unsigned long) (pc) & 7) {
4119 (void) memmove(pc - 4, pc, 8);
4120 pc -= 4;
4121 }
4122 #endif
4123
4124 FogCoorddv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
4125 }
4126
4127 void
__glXDispSwap_PointParameterf(GLbyte * pc)4128 __glXDispSwap_PointParameterf(GLbyte * pc)
4129 {
4130 PFNGLPOINTPARAMETERFPROC PointParameterf =
4131 __glGetProcAddress("glPointParameterf");
4132 PointParameterf((GLenum) bswap_ENUM(pc + 0),
4133 (GLfloat) bswap_FLOAT32(pc + 4));
4134 }
4135
4136 void
__glXDispSwap_PointParameterfv(GLbyte * pc)4137 __glXDispSwap_PointParameterfv(GLbyte * pc)
4138 {
4139 PFNGLPOINTPARAMETERFVPROC PointParameterfv =
4140 __glGetProcAddress("glPointParameterfv");
4141 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
4142 const GLfloat *params;
4143
4144 params =
4145 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
4146 __glPointParameterfv_size(pname));
4147
4148 PointParameterfv(pname, params);
4149 }
4150
4151 void
__glXDispSwap_PointParameteri(GLbyte * pc)4152 __glXDispSwap_PointParameteri(GLbyte * pc)
4153 {
4154 PFNGLPOINTPARAMETERIPROC PointParameteri =
4155 __glGetProcAddress("glPointParameteri");
4156 PointParameteri((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
4157 }
4158
4159 void
__glXDispSwap_PointParameteriv(GLbyte * pc)4160 __glXDispSwap_PointParameteriv(GLbyte * pc)
4161 {
4162 PFNGLPOINTPARAMETERIVPROC PointParameteriv =
4163 __glGetProcAddress("glPointParameteriv");
4164 const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
4165 const GLint *params;
4166
4167 params =
4168 (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
4169 __glPointParameteriv_size(pname));
4170
4171 PointParameteriv(pname, params);
4172 }
4173
4174 void
__glXDispSwap_SecondaryColor3bv(GLbyte * pc)4175 __glXDispSwap_SecondaryColor3bv(GLbyte * pc)
4176 {
4177 PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
4178 __glGetProcAddress("glSecondaryColor3bv");
4179 SecondaryColor3bv((const GLbyte *) (pc + 0));
4180 }
4181
4182 void
__glXDispSwap_SecondaryColor3dv(GLbyte * pc)4183 __glXDispSwap_SecondaryColor3dv(GLbyte * pc)
4184 {
4185 PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
4186 __glGetProcAddress("glSecondaryColor3dv");
4187 #ifdef __GLX_ALIGN64
4188 if ((unsigned long) (pc) & 7) {
4189 (void) memmove(pc - 4, pc, 24);
4190 pc -= 4;
4191 }
4192 #endif
4193
4194 SecondaryColor3dv((const GLdouble *)
4195 bswap_64_array((uint64_t *) (pc + 0), 3));
4196 }
4197
4198 void
__glXDispSwap_SecondaryColor3iv(GLbyte * pc)4199 __glXDispSwap_SecondaryColor3iv(GLbyte * pc)
4200 {
4201 PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv =
4202 __glGetProcAddress("glSecondaryColor3iv");
4203 SecondaryColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
4204 }
4205
4206 void
__glXDispSwap_SecondaryColor3sv(GLbyte * pc)4207 __glXDispSwap_SecondaryColor3sv(GLbyte * pc)
4208 {
4209 PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv =
4210 __glGetProcAddress("glSecondaryColor3sv");
4211 SecondaryColor3sv((const GLshort *)
4212 bswap_16_array((uint16_t *) (pc + 0), 3));
4213 }
4214
4215 void
__glXDispSwap_SecondaryColor3ubv(GLbyte * pc)4216 __glXDispSwap_SecondaryColor3ubv(GLbyte * pc)
4217 {
4218 PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
4219 __glGetProcAddress("glSecondaryColor3ubv");
4220 SecondaryColor3ubv((const GLubyte *) (pc + 0));
4221 }
4222
4223 void
__glXDispSwap_SecondaryColor3uiv(GLbyte * pc)4224 __glXDispSwap_SecondaryColor3uiv(GLbyte * pc)
4225 {
4226 PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv =
4227 __glGetProcAddress("glSecondaryColor3uiv");
4228 SecondaryColor3uiv((const GLuint *)
4229 bswap_32_array((uint32_t *) (pc + 0), 3));
4230 }
4231
4232 void
__glXDispSwap_SecondaryColor3usv(GLbyte * pc)4233 __glXDispSwap_SecondaryColor3usv(GLbyte * pc)
4234 {
4235 PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv =
4236 __glGetProcAddress("glSecondaryColor3usv");
4237 SecondaryColor3usv((const GLushort *)
4238 bswap_16_array((uint16_t *) (pc + 0), 3));
4239 }
4240
4241 void
__glXDispSwap_WindowPos3fv(GLbyte * pc)4242 __glXDispSwap_WindowPos3fv(GLbyte * pc)
4243 {
4244 PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv");
4245
4246 WindowPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
4247 }
4248
4249 void
__glXDispSwap_BeginQuery(GLbyte * pc)4250 __glXDispSwap_BeginQuery(GLbyte * pc)
4251 {
4252 PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery");
4253
4254 BeginQuery((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
4255 }
4256
4257 int
__glXDispSwap_DeleteQueries(__GLXclientState * cl,GLbyte * pc)4258 __glXDispSwap_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
4259 {
4260 PFNGLDELETEQUERIESPROC DeleteQueries =
4261 __glGetProcAddress("glDeleteQueries");
4262 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
4263 int error;
4264 __GLXcontext *const cx =
4265 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4266
4267 pc += __GLX_SINGLE_HDR_SIZE;
4268 if (cx != NULL) {
4269 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
4270
4271 DeleteQueries(n,
4272 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
4273 0));
4274 error = Success;
4275 }
4276
4277 return error;
4278 }
4279
4280 void
__glXDispSwap_EndQuery(GLbyte * pc)4281 __glXDispSwap_EndQuery(GLbyte * pc)
4282 {
4283 PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
4284
4285 EndQuery((GLenum) bswap_ENUM(pc + 0));
4286 }
4287
4288 int
__glXDispSwap_GenQueries(__GLXclientState * cl,GLbyte * pc)4289 __glXDispSwap_GenQueries(__GLXclientState * cl, GLbyte * pc)
4290 {
4291 PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries");
4292 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
4293 int error;
4294 __GLXcontext *const cx =
4295 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4296
4297 pc += __GLX_SINGLE_HDR_SIZE;
4298 if (cx != NULL) {
4299 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
4300
4301 GLuint answerBuffer[200];
4302 GLuint *ids =
4303 __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4304 4);
4305 if (ids == NULL)
4306 return BadAlloc;
4307
4308 GenQueries(n, ids);
4309 (void) bswap_32_array((uint32_t *) ids, n);
4310 __glXSendReplySwap(cl->client, ids, n, 4, GL_TRUE, 0);
4311 error = Success;
4312 }
4313
4314 return error;
4315 }
4316
4317 int
__glXDispSwap_GetQueryObjectiv(__GLXclientState * cl,GLbyte * pc)4318 __glXDispSwap_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
4319 {
4320 PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv =
4321 __glGetProcAddress("glGetQueryObjectiv");
4322 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
4323 int error;
4324 __GLXcontext *const cx =
4325 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4326
4327 pc += __GLX_SINGLE_HDR_SIZE;
4328 if (cx != NULL) {
4329 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
4330
4331 const GLuint compsize = __glGetQueryObjectiv_size(pname);
4332 GLint answerBuffer[200];
4333 GLint *params =
4334 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
4335 sizeof(answerBuffer), 4);
4336
4337 if (params == NULL)
4338 return BadAlloc;
4339 __glXClearErrorOccured();
4340
4341 GetQueryObjectiv((GLuint) bswap_CARD32(pc + 0), pname, params);
4342 (void) bswap_32_array((uint32_t *) params, compsize);
4343 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
4344 error = Success;
4345 }
4346
4347 return error;
4348 }
4349
4350 int
__glXDispSwap_GetQueryObjectuiv(__GLXclientState * cl,GLbyte * pc)4351 __glXDispSwap_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
4352 {
4353 PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv =
4354 __glGetProcAddress("glGetQueryObjectuiv");
4355 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
4356 int error;
4357 __GLXcontext *const cx =
4358 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4359
4360 pc += __GLX_SINGLE_HDR_SIZE;
4361 if (cx != NULL) {
4362 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
4363
4364 const GLuint compsize = __glGetQueryObjectuiv_size(pname);
4365 GLuint answerBuffer[200];
4366 GLuint *params =
4367 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
4368 sizeof(answerBuffer), 4);
4369
4370 if (params == NULL)
4371 return BadAlloc;
4372 __glXClearErrorOccured();
4373
4374 GetQueryObjectuiv((GLuint) bswap_CARD32(pc + 0), pname, params);
4375 (void) bswap_32_array((uint32_t *) params, compsize);
4376 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
4377 error = Success;
4378 }
4379
4380 return error;
4381 }
4382
4383 int
__glXDispSwap_GetQueryiv(__GLXclientState * cl,GLbyte * pc)4384 __glXDispSwap_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
4385 {
4386 PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv");
4387 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
4388 int error;
4389 __GLXcontext *const cx =
4390 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4391
4392 pc += __GLX_SINGLE_HDR_SIZE;
4393 if (cx != NULL) {
4394 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
4395
4396 const GLuint compsize = __glGetQueryiv_size(pname);
4397 GLint answerBuffer[200];
4398 GLint *params =
4399 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
4400 sizeof(answerBuffer), 4);
4401
4402 if (params == NULL)
4403 return BadAlloc;
4404 __glXClearErrorOccured();
4405
4406 GetQueryiv((GLenum) bswap_ENUM(pc + 0), pname, params);
4407 (void) bswap_32_array((uint32_t *) params, compsize);
4408 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
4409 error = Success;
4410 }
4411
4412 return error;
4413 }
4414
4415 int
__glXDispSwap_IsQuery(__GLXclientState * cl,GLbyte * pc)4416 __glXDispSwap_IsQuery(__GLXclientState * cl, GLbyte * pc)
4417 {
4418 PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery");
4419 xGLXSingleReq *const req = (xGLXSingleReq *) pc;
4420 int error;
4421 __GLXcontext *const cx =
4422 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4423
4424 pc += __GLX_SINGLE_HDR_SIZE;
4425 if (cx != NULL) {
4426 GLboolean retval;
4427
4428 retval = IsQuery((GLuint) bswap_CARD32(pc + 0));
4429 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
4430 error = Success;
4431 }
4432
4433 return error;
4434 }
4435
4436 void
__glXDispSwap_BlendEquationSeparate(GLbyte * pc)4437 __glXDispSwap_BlendEquationSeparate(GLbyte * pc)
4438 {
4439 PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate =
4440 __glGetProcAddress("glBlendEquationSeparate");
4441 BlendEquationSeparate((GLenum) bswap_ENUM(pc + 0),
4442 (GLenum) bswap_ENUM(pc + 4));
4443 }
4444
4445 void
__glXDispSwap_DrawBuffers(GLbyte * pc)4446 __glXDispSwap_DrawBuffers(GLbyte * pc)
4447 {
4448 PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers");
4449 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
4450
4451 DrawBuffers(n, (const GLenum *) bswap_32_array((uint32_t *) (pc + 4), 0));
4452 }
4453
4454 void
__glXDispSwap_VertexAttrib1dv(GLbyte * pc)4455 __glXDispSwap_VertexAttrib1dv(GLbyte * pc)
4456 {
4457 PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
4458 __glGetProcAddress("glVertexAttrib1dv");
4459 #ifdef __GLX_ALIGN64
4460 if ((unsigned long) (pc) & 7) {
4461 (void) memmove(pc - 4, pc, 12);
4462 pc -= 4;
4463 }
4464 #endif
4465
4466 VertexAttrib1dv((GLuint) bswap_CARD32(pc + 0),
4467 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
4468 1));
4469 }
4470
4471 void
__glXDispSwap_VertexAttrib1sv(GLbyte * pc)4472 __glXDispSwap_VertexAttrib1sv(GLbyte * pc)
4473 {
4474 PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv =
4475 __glGetProcAddress("glVertexAttrib1sv");
4476 VertexAttrib1sv((GLuint) bswap_CARD32(pc + 0),
4477 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 1));
4478 }
4479
4480 void
__glXDispSwap_VertexAttrib2dv(GLbyte * pc)4481 __glXDispSwap_VertexAttrib2dv(GLbyte * pc)
4482 {
4483 PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
4484 __glGetProcAddress("glVertexAttrib2dv");
4485 #ifdef __GLX_ALIGN64
4486 if ((unsigned long) (pc) & 7) {
4487 (void) memmove(pc - 4, pc, 20);
4488 pc -= 4;
4489 }
4490 #endif
4491
4492 VertexAttrib2dv((GLuint) bswap_CARD32(pc + 0),
4493 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
4494 2));
4495 }
4496
4497 void
__glXDispSwap_VertexAttrib2sv(GLbyte * pc)4498 __glXDispSwap_VertexAttrib2sv(GLbyte * pc)
4499 {
4500 PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv =
4501 __glGetProcAddress("glVertexAttrib2sv");
4502 VertexAttrib2sv((GLuint) bswap_CARD32(pc + 0),
4503 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2));
4504 }
4505
4506 void
__glXDispSwap_VertexAttrib3dv(GLbyte * pc)4507 __glXDispSwap_VertexAttrib3dv(GLbyte * pc)
4508 {
4509 PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
4510 __glGetProcAddress("glVertexAttrib3dv");
4511 #ifdef __GLX_ALIGN64
4512 if ((unsigned long) (pc) & 7) {
4513 (void) memmove(pc - 4, pc, 28);
4514 pc -= 4;
4515 }
4516 #endif
4517
4518 VertexAttrib3dv((GLuint) bswap_CARD32(pc + 0),
4519 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
4520 3));
4521 }
4522
4523 void
__glXDispSwap_VertexAttrib3sv(GLbyte * pc)4524 __glXDispSwap_VertexAttrib3sv(GLbyte * pc)
4525 {
4526 PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv =
4527 __glGetProcAddress("glVertexAttrib3sv");
4528 VertexAttrib3sv((GLuint) bswap_CARD32(pc + 0),
4529 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 3));
4530 }
4531
4532 void
__glXDispSwap_VertexAttrib4Nbv(GLbyte * pc)4533 __glXDispSwap_VertexAttrib4Nbv(GLbyte * pc)
4534 {
4535 PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv =
4536 __glGetProcAddress("glVertexAttrib4Nbv");
4537 VertexAttrib4Nbv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
4538 }
4539
4540 void
__glXDispSwap_VertexAttrib4Niv(GLbyte * pc)4541 __glXDispSwap_VertexAttrib4Niv(GLbyte * pc)
4542 {
4543 PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv =
4544 __glGetProcAddress("glVertexAttrib4Niv");
4545 VertexAttrib4Niv((GLuint) bswap_CARD32(pc + 0),
4546 (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
4547 }
4548
4549 void
__glXDispSwap_VertexAttrib4Nsv(GLbyte * pc)4550 __glXDispSwap_VertexAttrib4Nsv(GLbyte * pc)
4551 {
4552 PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv =
4553 __glGetProcAddress("glVertexAttrib4Nsv");
4554 VertexAttrib4Nsv((GLuint) bswap_CARD32(pc + 0),
4555 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
4556 4));
4557 }
4558
4559 void
__glXDispSwap_VertexAttrib4Nubv(GLbyte * pc)4560 __glXDispSwap_VertexAttrib4Nubv(GLbyte * pc)
4561 {
4562 PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv =
4563 __glGetProcAddress("glVertexAttrib4Nubv");
4564 VertexAttrib4Nubv((GLuint) bswap_CARD32(pc + 0),
4565 (const GLubyte *) (pc + 4));
4566 }
4567
4568 void
__glXDispSwap_VertexAttrib4Nuiv(GLbyte * pc)4569 __glXDispSwap_VertexAttrib4Nuiv(GLbyte * pc)
4570 {
4571 PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv =
4572 __glGetProcAddress("glVertexAttrib4Nuiv");
4573 VertexAttrib4Nuiv((GLuint) bswap_CARD32(pc + 0),
4574 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
4575 4));
4576 }
4577
4578 void
__glXDispSwap_VertexAttrib4Nusv(GLbyte * pc)4579 __glXDispSwap_VertexAttrib4Nusv(GLbyte * pc)
4580 {
4581 PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv =
4582 __glGetProcAddress("glVertexAttrib4Nusv");
4583 VertexAttrib4Nusv((GLuint) bswap_CARD32(pc + 0),
4584 (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
4585 4));
4586 }
4587
4588 void
__glXDispSwap_VertexAttrib4bv(GLbyte * pc)4589 __glXDispSwap_VertexAttrib4bv(GLbyte * pc)
4590 {
4591 PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv =
4592 __glGetProcAddress("glVertexAttrib4bv");
4593 VertexAttrib4bv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
4594 }
4595
4596 void
__glXDispSwap_VertexAttrib4dv(GLbyte * pc)4597 __glXDispSwap_VertexAttrib4dv(GLbyte * pc)
4598 {
4599 PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
4600 __glGetProcAddress("glVertexAttrib4dv");
4601 #ifdef __GLX_ALIGN64
4602 if ((unsigned long) (pc) & 7) {
4603 (void) memmove(pc - 4, pc, 36);
4604 pc -= 4;
4605 }
4606 #endif
4607
4608 VertexAttrib4dv((GLuint) bswap_CARD32(pc + 0),
4609 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
4610 4));
4611 }
4612
4613 void
__glXDispSwap_VertexAttrib4iv(GLbyte * pc)4614 __glXDispSwap_VertexAttrib4iv(GLbyte * pc)
4615 {
4616 PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv =
4617 __glGetProcAddress("glVertexAttrib4iv");
4618 VertexAttrib4iv((GLuint) bswap_CARD32(pc + 0),
4619 (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
4620 }
4621
4622 void
__glXDispSwap_VertexAttrib4sv(GLbyte * pc)4623 __glXDispSwap_VertexAttrib4sv(GLbyte * pc)
4624 {
4625 PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv =
4626 __glGetProcAddress("glVertexAttrib4sv");
4627 VertexAttrib4sv((GLuint) bswap_CARD32(pc + 0),
4628 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 4));
4629 }
4630
4631 void
__glXDispSwap_VertexAttrib4ubv(GLbyte * pc)4632 __glXDispSwap_VertexAttrib4ubv(GLbyte * pc)
4633 {
4634 PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv =
4635 __glGetProcAddress("glVertexAttrib4ubv");
4636 VertexAttrib4ubv((GLuint) bswap_CARD32(pc + 0), (const GLubyte *) (pc + 4));
4637 }
4638
4639 void
__glXDispSwap_VertexAttrib4uiv(GLbyte * pc)4640 __glXDispSwap_VertexAttrib4uiv(GLbyte * pc)
4641 {
4642 PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv =
4643 __glGetProcAddress("glVertexAttrib4uiv");
4644 VertexAttrib4uiv((GLuint) bswap_CARD32(pc + 0),
4645 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), 4));
4646 }
4647
4648 void
__glXDispSwap_VertexAttrib4usv(GLbyte * pc)4649 __glXDispSwap_VertexAttrib4usv(GLbyte * pc)
4650 {
4651 PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv =
4652 __glGetProcAddress("glVertexAttrib4usv");
4653 VertexAttrib4usv((GLuint) bswap_CARD32(pc + 0),
4654 (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
4655 4));
4656 }
4657
4658 void
__glXDispSwap_ClampColor(GLbyte * pc)4659 __glXDispSwap_ClampColor(GLbyte * pc)
4660 {
4661 PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor");
4662
4663 ClampColor((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
4664 }
4665
4666 void
__glXDispSwap_BindProgramARB(GLbyte * pc)4667 __glXDispSwap_BindProgramARB(GLbyte * pc)
4668 {
4669 PFNGLBINDPROGRAMARBPROC BindProgramARB =
4670 __glGetProcAddress("glBindProgramARB");
4671 BindProgramARB((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
4672 }
4673
4674 int
__glXDispSwap_DeleteProgramsARB(__GLXclientState * cl,GLbyte * pc)4675 __glXDispSwap_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
4676 {
4677 PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB =
4678 __glGetProcAddress("glDeleteProgramsARB");
4679 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4680 int error;
4681 __GLXcontext *const cx =
4682 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4683
4684 pc += __GLX_VENDPRIV_HDR_SIZE;
4685 if (cx != NULL) {
4686 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
4687
4688 DeleteProgramsARB(n,
4689 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
4690 0));
4691 error = Success;
4692 }
4693
4694 return error;
4695 }
4696
4697 int
__glXDispSwap_GenProgramsARB(__GLXclientState * cl,GLbyte * pc)4698 __glXDispSwap_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
4699 {
4700 PFNGLGENPROGRAMSARBPROC GenProgramsARB =
4701 __glGetProcAddress("glGenProgramsARB");
4702 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4703 int error;
4704 __GLXcontext *const cx =
4705 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4706
4707 pc += __GLX_VENDPRIV_HDR_SIZE;
4708 if (cx != NULL) {
4709 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
4710
4711 GLuint answerBuffer[200];
4712 GLuint *programs =
4713 __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4714 4);
4715 if (programs == NULL)
4716 return BadAlloc;
4717
4718 GenProgramsARB(n, programs);
4719 (void) bswap_32_array((uint32_t *) programs, n);
4720 __glXSendReplySwap(cl->client, programs, n, 4, GL_TRUE, 0);
4721 error = Success;
4722 }
4723
4724 return error;
4725 }
4726
4727 int
__glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState * cl,GLbyte * pc)4728 __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
4729 {
4730 PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB =
4731 __glGetProcAddress("glGetProgramEnvParameterdvARB");
4732 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4733 int error;
4734 __GLXcontext *const cx =
4735 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4736
4737 pc += __GLX_VENDPRIV_HDR_SIZE;
4738 if (cx != NULL) {
4739 GLdouble params[4];
4740
4741 GetProgramEnvParameterdvARB((GLenum) bswap_ENUM(pc + 0),
4742 (GLuint) bswap_CARD32(pc + 4), params);
4743 (void) bswap_64_array((uint64_t *) params, 4);
4744 __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
4745 error = Success;
4746 }
4747
4748 return error;
4749 }
4750
4751 int
__glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState * cl,GLbyte * pc)4752 __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
4753 {
4754 PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB =
4755 __glGetProcAddress("glGetProgramEnvParameterfvARB");
4756 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4757 int error;
4758 __GLXcontext *const cx =
4759 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4760
4761 pc += __GLX_VENDPRIV_HDR_SIZE;
4762 if (cx != NULL) {
4763 GLfloat params[4];
4764
4765 GetProgramEnvParameterfvARB((GLenum) bswap_ENUM(pc + 0),
4766 (GLuint) bswap_CARD32(pc + 4), params);
4767 (void) bswap_32_array((uint32_t *) params, 4);
4768 __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
4769 error = Success;
4770 }
4771
4772 return error;
4773 }
4774
4775 int
__glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState * cl,GLbyte * pc)4776 __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
4777 {
4778 PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB =
4779 __glGetProcAddress("glGetProgramLocalParameterdvARB");
4780 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4781 int error;
4782 __GLXcontext *const cx =
4783 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4784
4785 pc += __GLX_VENDPRIV_HDR_SIZE;
4786 if (cx != NULL) {
4787 GLdouble params[4];
4788
4789 GetProgramLocalParameterdvARB((GLenum) bswap_ENUM(pc + 0),
4790 (GLuint) bswap_CARD32(pc + 4), params);
4791 (void) bswap_64_array((uint64_t *) params, 4);
4792 __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
4793 error = Success;
4794 }
4795
4796 return error;
4797 }
4798
4799 int
__glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState * cl,GLbyte * pc)4800 __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
4801 {
4802 PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB =
4803 __glGetProcAddress("glGetProgramLocalParameterfvARB");
4804 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4805 int error;
4806 __GLXcontext *const cx =
4807 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4808
4809 pc += __GLX_VENDPRIV_HDR_SIZE;
4810 if (cx != NULL) {
4811 GLfloat params[4];
4812
4813 GetProgramLocalParameterfvARB((GLenum) bswap_ENUM(pc + 0),
4814 (GLuint) bswap_CARD32(pc + 4), params);
4815 (void) bswap_32_array((uint32_t *) params, 4);
4816 __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
4817 error = Success;
4818 }
4819
4820 return error;
4821 }
4822
4823 int
__glXDispSwap_GetProgramivARB(__GLXclientState * cl,GLbyte * pc)4824 __glXDispSwap_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
4825 {
4826 PFNGLGETPROGRAMIVARBPROC GetProgramivARB =
4827 __glGetProcAddress("glGetProgramivARB");
4828 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4829 int error;
4830 __GLXcontext *const cx =
4831 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4832
4833 pc += __GLX_VENDPRIV_HDR_SIZE;
4834 if (cx != NULL) {
4835 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
4836
4837 const GLuint compsize = __glGetProgramivARB_size(pname);
4838 GLint answerBuffer[200];
4839 GLint *params =
4840 __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
4841 sizeof(answerBuffer), 4);
4842
4843 if (params == NULL)
4844 return BadAlloc;
4845 __glXClearErrorOccured();
4846
4847 GetProgramivARB((GLenum) bswap_ENUM(pc + 0), pname, params);
4848 (void) bswap_32_array((uint32_t *) params, compsize);
4849 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
4850 error = Success;
4851 }
4852
4853 return error;
4854 }
4855
4856 int
__glXDispSwap_IsProgramARB(__GLXclientState * cl,GLbyte * pc)4857 __glXDispSwap_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
4858 {
4859 PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB");
4860 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
4861 int error;
4862 __GLXcontext *const cx =
4863 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
4864
4865 pc += __GLX_VENDPRIV_HDR_SIZE;
4866 if (cx != NULL) {
4867 GLboolean retval;
4868
4869 retval = IsProgramARB((GLuint) bswap_CARD32(pc + 0));
4870 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
4871 error = Success;
4872 }
4873
4874 return error;
4875 }
4876
4877 void
__glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)4878 __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
4879 {
4880 PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
4881 __glGetProcAddress("glProgramEnvParameter4dvARB");
4882 #ifdef __GLX_ALIGN64
4883 if ((unsigned long) (pc) & 7) {
4884 (void) memmove(pc - 4, pc, 40);
4885 pc -= 4;
4886 }
4887 #endif
4888
4889 ProgramEnvParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
4890 (GLuint) bswap_CARD32(pc + 4),
4891 (const GLdouble *)
4892 bswap_64_array((uint64_t *) (pc + 8), 4));
4893 }
4894
4895 void
__glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)4896 __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)
4897 {
4898 PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB =
4899 __glGetProcAddress("glProgramEnvParameter4fvARB");
4900 ProgramEnvParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
4901 (GLuint) bswap_CARD32(pc + 4),
4902 (const GLfloat *)
4903 bswap_32_array((uint32_t *) (pc + 8), 4));
4904 }
4905
4906 void
__glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)4907 __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
4908 {
4909 PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
4910 __glGetProcAddress("glProgramLocalParameter4dvARB");
4911 #ifdef __GLX_ALIGN64
4912 if ((unsigned long) (pc) & 7) {
4913 (void) memmove(pc - 4, pc, 40);
4914 pc -= 4;
4915 }
4916 #endif
4917
4918 ProgramLocalParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
4919 (GLuint) bswap_CARD32(pc + 4),
4920 (const GLdouble *)
4921 bswap_64_array((uint64_t *) (pc + 8), 4));
4922 }
4923
4924 void
__glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)4925 __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)
4926 {
4927 PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB =
4928 __glGetProcAddress("glProgramLocalParameter4fvARB");
4929 ProgramLocalParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
4930 (GLuint) bswap_CARD32(pc + 4),
4931 (const GLfloat *)
4932 bswap_32_array((uint32_t *) (pc + 8), 4));
4933 }
4934
4935 void
__glXDispSwap_ProgramStringARB(GLbyte * pc)4936 __glXDispSwap_ProgramStringARB(GLbyte * pc)
4937 {
4938 PFNGLPROGRAMSTRINGARBPROC ProgramStringARB =
4939 __glGetProcAddress("glProgramStringARB");
4940 const GLsizei len = (GLsizei) bswap_CARD32(pc + 8);
4941
4942 ProgramStringARB((GLenum) bswap_ENUM(pc + 0),
4943 (GLenum) bswap_ENUM(pc + 4),
4944 len, (const GLvoid *) (pc + 12));
4945 }
4946
4947 void
__glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)4948 __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)
4949 {
4950 PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB =
4951 __glGetProcAddress("glVertexAttrib1fvARB");
4952 VertexAttrib1fvARB((GLuint) bswap_CARD32(pc + 0),
4953 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
4954 1));
4955 }
4956
4957 void
__glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)4958 __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)
4959 {
4960 PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB =
4961 __glGetProcAddress("glVertexAttrib2fvARB");
4962 VertexAttrib2fvARB((GLuint) bswap_CARD32(pc + 0),
4963 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
4964 2));
4965 }
4966
4967 void
__glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)4968 __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)
4969 {
4970 PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB =
4971 __glGetProcAddress("glVertexAttrib3fvARB");
4972 VertexAttrib3fvARB((GLuint) bswap_CARD32(pc + 0),
4973 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
4974 3));
4975 }
4976
4977 void
__glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)4978 __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)
4979 {
4980 PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB =
4981 __glGetProcAddress("glVertexAttrib4fvARB");
4982 VertexAttrib4fvARB((GLuint) bswap_CARD32(pc + 0),
4983 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
4984 4));
4985 }
4986
4987 void
__glXDispSwap_BindFramebuffer(GLbyte * pc)4988 __glXDispSwap_BindFramebuffer(GLbyte * pc)
4989 {
4990 PFNGLBINDFRAMEBUFFERPROC BindFramebuffer =
4991 __glGetProcAddress("glBindFramebuffer");
4992 BindFramebuffer((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
4993 }
4994
4995 void
__glXDispSwap_BindRenderbuffer(GLbyte * pc)4996 __glXDispSwap_BindRenderbuffer(GLbyte * pc)
4997 {
4998 PFNGLBINDRENDERBUFFERPROC BindRenderbuffer =
4999 __glGetProcAddress("glBindRenderbuffer");
5000 BindRenderbuffer((GLenum) bswap_ENUM(pc + 0),
5001 (GLuint) bswap_CARD32(pc + 4));
5002 }
5003
5004 void
__glXDispSwap_BlitFramebuffer(GLbyte * pc)5005 __glXDispSwap_BlitFramebuffer(GLbyte * pc)
5006 {
5007 PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer =
5008 __glGetProcAddress("glBlitFramebuffer");
5009 BlitFramebuffer((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4),
5010 (GLint) bswap_CARD32(pc + 8), (GLint) bswap_CARD32(pc + 12),
5011 (GLint) bswap_CARD32(pc + 16),
5012 (GLint) bswap_CARD32(pc + 20),
5013 (GLint) bswap_CARD32(pc + 24),
5014 (GLint) bswap_CARD32(pc + 28),
5015 (GLbitfield) bswap_CARD32(pc + 32),
5016 (GLenum) bswap_ENUM(pc + 36));
5017 }
5018
5019 int
__glXDispSwap_CheckFramebufferStatus(__GLXclientState * cl,GLbyte * pc)5020 __glXDispSwap_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
5021 {
5022 PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus =
5023 __glGetProcAddress("glCheckFramebufferStatus");
5024 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5025 int error;
5026 __GLXcontext *const cx =
5027 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5028
5029 pc += __GLX_VENDPRIV_HDR_SIZE;
5030 if (cx != NULL) {
5031 GLenum retval;
5032
5033 retval = CheckFramebufferStatus((GLenum) bswap_ENUM(pc + 0));
5034 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5035 error = Success;
5036 }
5037
5038 return error;
5039 }
5040
5041 void
__glXDispSwap_DeleteFramebuffers(GLbyte * pc)5042 __glXDispSwap_DeleteFramebuffers(GLbyte * pc)
5043 {
5044 PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers =
5045 __glGetProcAddress("glDeleteFramebuffers");
5046 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
5047
5048 DeleteFramebuffers(n,
5049 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
5050 0));
5051 }
5052
5053 void
__glXDispSwap_DeleteRenderbuffers(GLbyte * pc)5054 __glXDispSwap_DeleteRenderbuffers(GLbyte * pc)
5055 {
5056 PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers =
5057 __glGetProcAddress("glDeleteRenderbuffers");
5058 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
5059
5060 DeleteRenderbuffers(n,
5061 (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
5062 0));
5063 }
5064
5065 void
__glXDispSwap_FramebufferRenderbuffer(GLbyte * pc)5066 __glXDispSwap_FramebufferRenderbuffer(GLbyte * pc)
5067 {
5068 PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer =
5069 __glGetProcAddress("glFramebufferRenderbuffer");
5070 FramebufferRenderbuffer((GLenum) bswap_ENUM(pc + 0),
5071 (GLenum) bswap_ENUM(pc + 4),
5072 (GLenum) bswap_ENUM(pc + 8),
5073 (GLuint) bswap_CARD32(pc + 12));
5074 }
5075
5076 void
__glXDispSwap_FramebufferTexture1D(GLbyte * pc)5077 __glXDispSwap_FramebufferTexture1D(GLbyte * pc)
5078 {
5079 PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D =
5080 __glGetProcAddress("glFramebufferTexture1D");
5081 FramebufferTexture1D((GLenum) bswap_ENUM(pc + 0),
5082 (GLenum) bswap_ENUM(pc + 4),
5083 (GLenum) bswap_ENUM(pc + 8),
5084 (GLuint) bswap_CARD32(pc + 12),
5085 (GLint) bswap_CARD32(pc + 16));
5086 }
5087
5088 void
__glXDispSwap_FramebufferTexture2D(GLbyte * pc)5089 __glXDispSwap_FramebufferTexture2D(GLbyte * pc)
5090 {
5091 PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D =
5092 __glGetProcAddress("glFramebufferTexture2D");
5093 FramebufferTexture2D((GLenum) bswap_ENUM(pc + 0),
5094 (GLenum) bswap_ENUM(pc + 4),
5095 (GLenum) bswap_ENUM(pc + 8),
5096 (GLuint) bswap_CARD32(pc + 12),
5097 (GLint) bswap_CARD32(pc + 16));
5098 }
5099
5100 void
__glXDispSwap_FramebufferTexture3D(GLbyte * pc)5101 __glXDispSwap_FramebufferTexture3D(GLbyte * pc)
5102 {
5103 PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D =
5104 __glGetProcAddress("glFramebufferTexture3D");
5105 FramebufferTexture3D((GLenum) bswap_ENUM(pc + 0),
5106 (GLenum) bswap_ENUM(pc + 4),
5107 (GLenum) bswap_ENUM(pc + 8),
5108 (GLuint) bswap_CARD32(pc + 12),
5109 (GLint) bswap_CARD32(pc + 16),
5110 (GLint) bswap_CARD32(pc + 20));
5111 }
5112
5113 void
__glXDispSwap_FramebufferTextureLayer(GLbyte * pc)5114 __glXDispSwap_FramebufferTextureLayer(GLbyte * pc)
5115 {
5116 PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer =
5117 __glGetProcAddress("glFramebufferTextureLayer");
5118 FramebufferTextureLayer((GLenum) bswap_ENUM(pc + 0),
5119 (GLenum) bswap_ENUM(pc + 4),
5120 (GLuint) bswap_CARD32(pc + 8),
5121 (GLint) bswap_CARD32(pc + 12),
5122 (GLint) bswap_CARD32(pc + 16));
5123 }
5124
5125 int
__glXDispSwap_GenFramebuffers(__GLXclientState * cl,GLbyte * pc)5126 __glXDispSwap_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
5127 {
5128 PFNGLGENFRAMEBUFFERSPROC GenFramebuffers =
5129 __glGetProcAddress("glGenFramebuffers");
5130 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5131 int error;
5132 __GLXcontext *const cx =
5133 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5134
5135 pc += __GLX_VENDPRIV_HDR_SIZE;
5136 if (cx != NULL) {
5137 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
5138
5139 GLuint answerBuffer[200];
5140 GLuint *framebuffers =
5141 __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
5142 4);
5143
5144 if (framebuffers == NULL)
5145 return BadAlloc;
5146
5147 GenFramebuffers(n, framebuffers);
5148 (void) bswap_32_array((uint32_t *) framebuffers, n);
5149 __glXSendReplySwap(cl->client, framebuffers, n, 4, GL_TRUE, 0);
5150 error = Success;
5151 }
5152
5153 return error;
5154 }
5155
5156 int
__glXDispSwap_GenRenderbuffers(__GLXclientState * cl,GLbyte * pc)5157 __glXDispSwap_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
5158 {
5159 PFNGLGENRENDERBUFFERSPROC GenRenderbuffers =
5160 __glGetProcAddress("glGenRenderbuffers");
5161 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5162 int error;
5163 __GLXcontext *const cx =
5164 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5165
5166 pc += __GLX_VENDPRIV_HDR_SIZE;
5167 if (cx != NULL) {
5168 const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
5169
5170 GLuint answerBuffer[200];
5171 GLuint *renderbuffers =
5172 __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
5173 4);
5174
5175 if (renderbuffers == NULL)
5176 return BadAlloc;
5177
5178 GenRenderbuffers(n, renderbuffers);
5179 (void) bswap_32_array((uint32_t *) renderbuffers, n);
5180 __glXSendReplySwap(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
5181 error = Success;
5182 }
5183
5184 return error;
5185 }
5186
5187 void
__glXDispSwap_GenerateMipmap(GLbyte * pc)5188 __glXDispSwap_GenerateMipmap(GLbyte * pc)
5189 {
5190 PFNGLGENERATEMIPMAPPROC GenerateMipmap =
5191 __glGetProcAddress("glGenerateMipmap");
5192 GenerateMipmap((GLenum) bswap_ENUM(pc + 0));
5193 }
5194
5195 int
__glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,GLbyte * pc)5196 __glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
5197 GLbyte * pc)
5198 {
5199 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
5200 GetFramebufferAttachmentParameteriv =
5201 __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
5202 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5203 int error;
5204 __GLXcontext *const cx =
5205 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5206
5207 pc += __GLX_VENDPRIV_HDR_SIZE;
5208 if (cx != NULL) {
5209 GLint params[1];
5210
5211 GetFramebufferAttachmentParameteriv((GLenum) bswap_ENUM(pc + 0),
5212 (GLenum) bswap_ENUM(pc + 4),
5213 (GLenum) bswap_ENUM(pc + 8),
5214 params);
5215 (void) bswap_32_array((uint32_t *) params, 1);
5216 __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
5217 error = Success;
5218 }
5219
5220 return error;
5221 }
5222
5223 int
__glXDispSwap_GetRenderbufferParameteriv(__GLXclientState * cl,GLbyte * pc)5224 __glXDispSwap_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
5225 {
5226 PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv =
5227 __glGetProcAddress("glGetRenderbufferParameteriv");
5228 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5229 int error;
5230 __GLXcontext *const cx =
5231 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5232
5233 pc += __GLX_VENDPRIV_HDR_SIZE;
5234 if (cx != NULL) {
5235 GLint params[1];
5236
5237 GetRenderbufferParameteriv((GLenum) bswap_ENUM(pc + 0),
5238 (GLenum) bswap_ENUM(pc + 4), params);
5239 (void) bswap_32_array((uint32_t *) params, 1);
5240 __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
5241 error = Success;
5242 }
5243
5244 return error;
5245 }
5246
5247 int
__glXDispSwap_IsFramebuffer(__GLXclientState * cl,GLbyte * pc)5248 __glXDispSwap_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
5249 {
5250 PFNGLISFRAMEBUFFERPROC IsFramebuffer =
5251 __glGetProcAddress("glIsFramebuffer");
5252 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5253 int error;
5254 __GLXcontext *const cx =
5255 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5256
5257 pc += __GLX_VENDPRIV_HDR_SIZE;
5258 if (cx != NULL) {
5259 GLboolean retval;
5260
5261 retval = IsFramebuffer((GLuint) bswap_CARD32(pc + 0));
5262 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5263 error = Success;
5264 }
5265
5266 return error;
5267 }
5268
5269 int
__glXDispSwap_IsRenderbuffer(__GLXclientState * cl,GLbyte * pc)5270 __glXDispSwap_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
5271 {
5272 PFNGLISRENDERBUFFERPROC IsRenderbuffer =
5273 __glGetProcAddress("glIsRenderbuffer");
5274 xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
5275 int error;
5276 __GLXcontext *const cx =
5277 __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
5278
5279 pc += __GLX_VENDPRIV_HDR_SIZE;
5280 if (cx != NULL) {
5281 GLboolean retval;
5282
5283 retval = IsRenderbuffer((GLuint) bswap_CARD32(pc + 0));
5284 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
5285 error = Success;
5286 }
5287
5288 return error;
5289 }
5290
5291 void
__glXDispSwap_RenderbufferStorage(GLbyte * pc)5292 __glXDispSwap_RenderbufferStorage(GLbyte * pc)
5293 {
5294 PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage =
5295 __glGetProcAddress("glRenderbufferStorage");
5296 RenderbufferStorage((GLenum) bswap_ENUM(pc + 0),
5297 (GLenum) bswap_ENUM(pc + 4),
5298 (GLsizei) bswap_CARD32(pc + 8),
5299 (GLsizei) bswap_CARD32(pc + 12));
5300 }
5301
5302 void
__glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc)5303 __glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc)
5304 {
5305 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample =
5306 __glGetProcAddress("glRenderbufferStorageMultisample");
5307 RenderbufferStorageMultisample((GLenum) bswap_ENUM(pc + 0),
5308 (GLsizei) bswap_CARD32(pc + 4),
5309 (GLenum) bswap_ENUM(pc + 8),
5310 (GLsizei) bswap_CARD32(pc + 12),
5311 (GLsizei) bswap_CARD32(pc + 16));
5312 }
5313
5314 void
__glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)5315 __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)
5316 {
5317 PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT =
5318 __glGetProcAddress("glSecondaryColor3fvEXT");
5319 SecondaryColor3fvEXT((const GLfloat *)
5320 bswap_32_array((uint32_t *) (pc + 0), 3));
5321 }
5322
5323 void
__glXDispSwap_FogCoordfvEXT(GLbyte * pc)5324 __glXDispSwap_FogCoordfvEXT(GLbyte * pc)
5325 {
5326 PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT =
5327 __glGetProcAddress("glFogCoordfvEXT");
5328 FogCoordfvEXT((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
5329 }
5330
5331 void
__glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)5332 __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
5333 {
5334 PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
5335 __glGetProcAddress("glVertexAttrib1dvNV");
5336 #ifdef __GLX_ALIGN64
5337 if ((unsigned long) (pc) & 7) {
5338 (void) memmove(pc - 4, pc, 12);
5339 pc -= 4;
5340 }
5341 #endif
5342
5343 VertexAttrib1dvNV((GLuint) bswap_CARD32(pc + 0),
5344 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
5345 1));
5346 }
5347
5348 void
__glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)5349 __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)
5350 {
5351 PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV =
5352 __glGetProcAddress("glVertexAttrib1fvNV");
5353 VertexAttrib1fvNV((GLuint) bswap_CARD32(pc + 0),
5354 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
5355 1));
5356 }
5357
5358 void
__glXDispSwap_VertexAttrib1svNV(GLbyte * pc)5359 __glXDispSwap_VertexAttrib1svNV(GLbyte * pc)
5360 {
5361 PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV =
5362 __glGetProcAddress("glVertexAttrib1svNV");
5363 VertexAttrib1svNV((GLuint) bswap_CARD32(pc + 0),
5364 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
5365 1));
5366 }
5367
5368 void
__glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)5369 __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
5370 {
5371 PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
5372 __glGetProcAddress("glVertexAttrib2dvNV");
5373 #ifdef __GLX_ALIGN64
5374 if ((unsigned long) (pc) & 7) {
5375 (void) memmove(pc - 4, pc, 20);
5376 pc -= 4;
5377 }
5378 #endif
5379
5380 VertexAttrib2dvNV((GLuint) bswap_CARD32(pc + 0),
5381 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
5382 2));
5383 }
5384
5385 void
__glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)5386 __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)
5387 {
5388 PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV =
5389 __glGetProcAddress("glVertexAttrib2fvNV");
5390 VertexAttrib2fvNV((GLuint) bswap_CARD32(pc + 0),
5391 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
5392 2));
5393 }
5394
5395 void
__glXDispSwap_VertexAttrib2svNV(GLbyte * pc)5396 __glXDispSwap_VertexAttrib2svNV(GLbyte * pc)
5397 {
5398 PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV =
5399 __glGetProcAddress("glVertexAttrib2svNV");
5400 VertexAttrib2svNV((GLuint) bswap_CARD32(pc + 0),
5401 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
5402 2));
5403 }
5404
5405 void
__glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)5406 __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
5407 {
5408 PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
5409 __glGetProcAddress("glVertexAttrib3dvNV");
5410 #ifdef __GLX_ALIGN64
5411 if ((unsigned long) (pc) & 7) {
5412 (void) memmove(pc - 4, pc, 28);
5413 pc -= 4;
5414 }
5415 #endif
5416
5417 VertexAttrib3dvNV((GLuint) bswap_CARD32(pc + 0),
5418 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
5419 3));
5420 }
5421
5422 void
__glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)5423 __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)
5424 {
5425 PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV =
5426 __glGetProcAddress("glVertexAttrib3fvNV");
5427 VertexAttrib3fvNV((GLuint) bswap_CARD32(pc + 0),
5428 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
5429 3));
5430 }
5431
5432 void
__glXDispSwap_VertexAttrib3svNV(GLbyte * pc)5433 __glXDispSwap_VertexAttrib3svNV(GLbyte * pc)
5434 {
5435 PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV =
5436 __glGetProcAddress("glVertexAttrib3svNV");
5437 VertexAttrib3svNV((GLuint) bswap_CARD32(pc + 0),
5438 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
5439 3));
5440 }
5441
5442 void
__glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)5443 __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
5444 {
5445 PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
5446 __glGetProcAddress("glVertexAttrib4dvNV");
5447 #ifdef __GLX_ALIGN64
5448 if ((unsigned long) (pc) & 7) {
5449 (void) memmove(pc - 4, pc, 36);
5450 pc -= 4;
5451 }
5452 #endif
5453
5454 VertexAttrib4dvNV((GLuint) bswap_CARD32(pc + 0),
5455 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
5456 4));
5457 }
5458
5459 void
__glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)5460 __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)
5461 {
5462 PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV =
5463 __glGetProcAddress("glVertexAttrib4fvNV");
5464 VertexAttrib4fvNV((GLuint) bswap_CARD32(pc + 0),
5465 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
5466 4));
5467 }
5468
5469 void
__glXDispSwap_VertexAttrib4svNV(GLbyte * pc)5470 __glXDispSwap_VertexAttrib4svNV(GLbyte * pc)
5471 {
5472 PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV =
5473 __glGetProcAddress("glVertexAttrib4svNV");
5474 VertexAttrib4svNV((GLuint) bswap_CARD32(pc + 0),
5475 (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
5476 4));
5477 }
5478
5479 void
__glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)5480 __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)
5481 {
5482 PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV =
5483 __glGetProcAddress("glVertexAttrib4ubvNV");
5484 VertexAttrib4ubvNV((GLuint) bswap_CARD32(pc + 0),
5485 (const GLubyte *) (pc + 4));
5486 }
5487
5488 void
__glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)5489 __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
5490 {
5491 PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV =
5492 __glGetProcAddress("glVertexAttribs1dvNV");
5493 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5494
5495 #ifdef __GLX_ALIGN64
5496 const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
5497
5498 if ((unsigned long) (pc) & 7) {
5499 (void) memmove(pc - 4, pc, cmdlen);
5500 pc -= 4;
5501 }
5502 #endif
5503
5504 VertexAttribs1dvNV((GLuint) bswap_CARD32(pc + 0),
5505 n,
5506 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
5507 0));
5508 }
5509
5510 void
__glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)5511 __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)
5512 {
5513 PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV =
5514 __glGetProcAddress("glVertexAttribs1fvNV");
5515 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5516
5517 VertexAttribs1fvNV((GLuint) bswap_CARD32(pc + 0),
5518 n,
5519 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
5520 0));
5521 }
5522
5523 void
__glXDispSwap_VertexAttribs1svNV(GLbyte * pc)5524 __glXDispSwap_VertexAttribs1svNV(GLbyte * pc)
5525 {
5526 PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV =
5527 __glGetProcAddress("glVertexAttribs1svNV");
5528 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5529
5530 VertexAttribs1svNV((GLuint) bswap_CARD32(pc + 0),
5531 n,
5532 (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
5533 0));
5534 }
5535
5536 void
__glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)5537 __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
5538 {
5539 PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV =
5540 __glGetProcAddress("glVertexAttribs2dvNV");
5541 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5542
5543 #ifdef __GLX_ALIGN64
5544 const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
5545
5546 if ((unsigned long) (pc) & 7) {
5547 (void) memmove(pc - 4, pc, cmdlen);
5548 pc -= 4;
5549 }
5550 #endif
5551
5552 VertexAttribs2dvNV((GLuint) bswap_CARD32(pc + 0),
5553 n,
5554 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
5555 0));
5556 }
5557
5558 void
__glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)5559 __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)
5560 {
5561 PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV =
5562 __glGetProcAddress("glVertexAttribs2fvNV");
5563 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5564
5565 VertexAttribs2fvNV((GLuint) bswap_CARD32(pc + 0),
5566 n,
5567 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
5568 0));
5569 }
5570
5571 void
__glXDispSwap_VertexAttribs2svNV(GLbyte * pc)5572 __glXDispSwap_VertexAttribs2svNV(GLbyte * pc)
5573 {
5574 PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV =
5575 __glGetProcAddress("glVertexAttribs2svNV");
5576 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5577
5578 VertexAttribs2svNV((GLuint) bswap_CARD32(pc + 0),
5579 n,
5580 (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
5581 0));
5582 }
5583
5584 void
__glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)5585 __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
5586 {
5587 PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV =
5588 __glGetProcAddress("glVertexAttribs3dvNV");
5589 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5590
5591 #ifdef __GLX_ALIGN64
5592 const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
5593
5594 if ((unsigned long) (pc) & 7) {
5595 (void) memmove(pc - 4, pc, cmdlen);
5596 pc -= 4;
5597 }
5598 #endif
5599
5600 VertexAttribs3dvNV((GLuint) bswap_CARD32(pc + 0),
5601 n,
5602 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
5603 0));
5604 }
5605
5606 void
__glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)5607 __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)
5608 {
5609 PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV =
5610 __glGetProcAddress("glVertexAttribs3fvNV");
5611 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5612
5613 VertexAttribs3fvNV((GLuint) bswap_CARD32(pc + 0),
5614 n,
5615 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
5616 0));
5617 }
5618
5619 void
__glXDispSwap_VertexAttribs3svNV(GLbyte * pc)5620 __glXDispSwap_VertexAttribs3svNV(GLbyte * pc)
5621 {
5622 PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV =
5623 __glGetProcAddress("glVertexAttribs3svNV");
5624 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5625
5626 VertexAttribs3svNV((GLuint) bswap_CARD32(pc + 0),
5627 n,
5628 (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
5629 0));
5630 }
5631
5632 void
__glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)5633 __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
5634 {
5635 PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV =
5636 __glGetProcAddress("glVertexAttribs4dvNV");
5637 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5638
5639 #ifdef __GLX_ALIGN64
5640 const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
5641
5642 if ((unsigned long) (pc) & 7) {
5643 (void) memmove(pc - 4, pc, cmdlen);
5644 pc -= 4;
5645 }
5646 #endif
5647
5648 VertexAttribs4dvNV((GLuint) bswap_CARD32(pc + 0),
5649 n,
5650 (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
5651 0));
5652 }
5653
5654 void
__glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)5655 __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)
5656 {
5657 PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV =
5658 __glGetProcAddress("glVertexAttribs4fvNV");
5659 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5660
5661 VertexAttribs4fvNV((GLuint) bswap_CARD32(pc + 0),
5662 n,
5663 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
5664 0));
5665 }
5666
5667 void
__glXDispSwap_VertexAttribs4svNV(GLbyte * pc)5668 __glXDispSwap_VertexAttribs4svNV(GLbyte * pc)
5669 {
5670 PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV =
5671 __glGetProcAddress("glVertexAttribs4svNV");
5672 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5673
5674 VertexAttribs4svNV((GLuint) bswap_CARD32(pc + 0),
5675 n,
5676 (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
5677 0));
5678 }
5679
5680 void
__glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)5681 __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)
5682 {
5683 PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV =
5684 __glGetProcAddress("glVertexAttribs4ubvNV");
5685 const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
5686
5687 VertexAttribs4ubvNV((GLuint) bswap_CARD32(pc + 0),
5688 n, (const GLubyte *) (pc + 8));
5689 }
5690
5691 void
__glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)5692 __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
5693 {
5694 PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
5695 __glGetProcAddress("glActiveStencilFaceEXT");
5696 ActiveStencilFaceEXT((GLenum) bswap_ENUM(pc + 0));
5697 }
5698