Bug Summary

File:glx/indirect_dispatch_swap.c
Location:line 1801, column 5
Description:Value stored to 'pc' is never read

Annotated Source Code

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) (((x) + 3) & ~3)
38
39typedef struct {
40 __GLX_PIXEL_3D_HDRBOOL swapBytes; BOOL lsbFirst; CARD8 reserved0; CARD8 reserved1
; CARD32 rowLength ; CARD32 imageHeight ; CARD32 imageDepth ;
CARD32 skipRows ; CARD32 skipImages ; CARD32 skipVolumes ; CARD32
skipPixels ; CARD32 alignment
;
41} __GLXpixel3DHeader;
42
43extern GLboolean __glXErrorOccured(void);
44extern void __glXClearErrorOccured(void);
45
46static const unsigned dummy_answer[2] = { 0, 0 };
47
48static GLsizei
49bswap_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)(__builtin_constant_p(*(uint32_t *) src) ? ((__uint32_t)((((__uint32_t
)(*(uint32_t *) src) & 0xff000000) >> 24) | (((__uint32_t
)(*(uint32_t *) src) & 0x00ff0000) >> 8) | (((__uint32_t
)(*(uint32_t *) src) & 0x0000ff00) << 8) | (((__uint32_t
)(*(uint32_t *) src) & 0x000000ff) << 24))) : _OSSwapInt32
(*(uint32_t *) src))
;
57 return x.ret;
58}
59
60static GLshort
61bswap_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)((__uint16_t)(__builtin_constant_p(*(uint16_t *) src) ? ((__uint16_t
)((((__uint16_t)(*(uint16_t *) src) & 0xff00) >> 8)
| (((__uint16_t)(*(uint16_t *) src) & 0x00ff) << 8
))) : _OSSwapInt16(*(uint16_t *) src)))
;
69 return x.ret;
70}
71
72static GLenum
73bswap_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)(__builtin_constant_p(*(uint32_t *) src) ? ((__uint32_t)((((__uint32_t
)(*(uint32_t *) src) & 0xff000000) >> 24) | (((__uint32_t
)(*(uint32_t *) src) & 0x00ff0000) >> 8) | (((__uint32_t
)(*(uint32_t *) src) & 0x0000ff00) << 8) | (((__uint32_t
)(*(uint32_t *) src) & 0x000000ff) << 24))) : _OSSwapInt32
(*(uint32_t *) src))
;
81 return x.ret;
82}
83
84static GLsync
85bswap_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)(__builtin_constant_p(*(uint64_t *) src) ? ((__uint64_t)((((__uint64_t
)(*(uint64_t *) src) & 0xff00000000000000ULL) >> 56
) | (((__uint64_t)(*(uint64_t *) src) & 0x00ff000000000000ULL
) >> 40) | (((__uint64_t)(*(uint64_t *) src) & 0x0000ff0000000000ULL
) >> 24) | (((__uint64_t)(*(uint64_t *) src) & 0x000000ff00000000ULL
) >> 8) | (((__uint64_t)(*(uint64_t *) src) & 0x00000000ff000000ULL
) << 8) | (((__uint64_t)(*(uint64_t *) src) & 0x0000000000ff0000ULL
) << 24) | (((__uint64_t)(*(uint64_t *) src) & 0x000000000000ff00ULL
) << 40) | (((__uint64_t)(*(uint64_t *) src) & 0x00000000000000ffULL
) << 56))) : _OSSwapInt64(*(uint64_t *) src))
;
93 return x.ret;
94}
95
96static GLdouble
97bswap_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)(__builtin_constant_p(*(uint64_t *) src) ? ((__uint64_t)((((__uint64_t
)(*(uint64_t *) src) & 0xff00000000000000ULL) >> 56
) | (((__uint64_t)(*(uint64_t *) src) & 0x00ff000000000000ULL
) >> 40) | (((__uint64_t)(*(uint64_t *) src) & 0x0000ff0000000000ULL
) >> 24) | (((__uint64_t)(*(uint64_t *) src) & 0x000000ff00000000ULL
) >> 8) | (((__uint64_t)(*(uint64_t *) src) & 0x00000000ff000000ULL
) << 8) | (((__uint64_t)(*(uint64_t *) src) & 0x0000000000ff0000ULL
) << 24) | (((__uint64_t)(*(uint64_t *) src) & 0x000000000000ff00ULL
) << 40) | (((__uint64_t)(*(uint64_t *) src) & 0x00000000000000ffULL
) << 56))) : _OSSwapInt64(*(uint64_t *) src))
;
105 return x.ret;
106}
107
108static GLfloat
109bswap_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)(__builtin_constant_p(*(uint32_t *) src) ? ((__uint32_t)((((__uint32_t
)(*(uint32_t *) src) & 0xff000000) >> 24) | (((__uint32_t
)(*(uint32_t *) src) & 0x00ff0000) >> 8) | (((__uint32_t
)(*(uint32_t *) src) & 0x0000ff00) << 8) | (((__uint32_t
)(*(uint32_t *) src) & 0x000000ff) << 24))) : _OSSwapInt32
(*(uint32_t *) src))
;
117 return x.ret;
118}
119
120static void *
121bswap_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])((__uint16_t)(__builtin_constant_p(src[i]) ? ((__uint16_t)(((
(__uint16_t)(src[i]) & 0xff00) >> 8) | (((__uint16_t
)(src[i]) & 0x00ff) << 8))) : _OSSwapInt16(src[i]))
)
;
127
128 src[i] = temp;
129 }
130
131 return src;
132}
133
134static void *
135bswap_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])(__builtin_constant_p(src[i]) ? ((__uint32_t)((((__uint32_t)(
src[i]) & 0xff000000) >> 24) | (((__uint32_t)(src[i
]) & 0x00ff0000) >> 8) | (((__uint32_t)(src[i]) &
0x0000ff00) << 8) | (((__uint32_t)(src[i]) & 0x000000ff
) << 24))) : _OSSwapInt32(src[i]))
;
141
142 src[i] = temp;
143 }
144
145 return src;
146}
147
148static void *
149bswap_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])(__builtin_constant_p(src[i]) ? ((__uint64_t)((((__uint64_t)(
src[i]) & 0xff00000000000000ULL) >> 56) | (((__uint64_t
)(src[i]) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t
)(src[i]) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t
)(src[i]) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t
)(src[i]) & 0x00000000ff000000ULL) << 8) | (((__uint64_t
)(src[i]) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t
)(src[i]) & 0x000000000000ff00ULL) << 40) | (((__uint64_t
)(src[i]) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64
(src[i]))
;
155
156 src[i] = temp;
157 }
158
159 return src;
160}
161
162int
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_SIZE8;
171 if (cx != NULL((void*)0)) {
172 glNewList((GLuint) bswap_CARD32(pc + 0), (GLenum) bswap_ENUM(pc + 4));
173 error = Success0;
174 }
175
176 return error;
177}
178
179int
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_SIZE8;
188 if (cx != NULL((void*)0)) {
189 glEndList();
190 error = Success0;
191 }
192
193 return error;
194}
195
196void
197__glXDispSwap_CallList(GLbyte * pc)
198{
199 glCallList((GLuint) bswap_CARD32(pc + 0));
200}
201
202void
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_BYTE0x1400:
211 case GL_UNSIGNED_BYTE0x1401:
212 case GL_2_BYTES0x1407:
213 case GL_3_BYTES0x1408:
214 case GL_4_BYTES0x1409:
215 lists = (const GLvoid *) (pc + 8);
216 break;
217 case GL_SHORT0x1402:
218 case GL_UNSIGNED_SHORT0x1403:
219 lists = (const GLvoid *) bswap_16_array((uint16_t *) (pc + 8), n);
220 break;
221 case GL_INT0x1404:
222 case GL_UNSIGNED_INT0x1405:
223 case GL_FLOAT0x1406:
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
233int
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_SIZE8;
242 if (cx != NULL((void*)0)) {
243 glDeleteLists((GLuint) bswap_CARD32(pc + 0),
244 (GLsizei) bswap_CARD32(pc + 4));
245 error = Success0;
246 }
247
248 return error;
249}
250
251int
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_SIZE8;
260 if (cx != NULL((void*)0)) {
261 GLuint retval;
262
263 retval = glGenLists((GLsizei) bswap_CARD32(pc + 0));
264 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
265 error = Success0;
266 }
267
268 return error;
269}
270
271void
272__glXDispSwap_ListBase(GLbyte * pc)
273{
274 glListBase((GLuint) bswap_CARD32(pc + 0));
275}
276
277void
278__glXDispSwap_Begin(GLbyte * pc)
279{
280 glBegin((GLenum) bswap_ENUM(pc + 0));
281}
282
283void
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_FIRST0x0CF1, hdr->lsbFirst);
290 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
291 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
292 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
293 (GLint) bswap_CARD32(&hdr->skipPixels));
294 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
304void
305__glXDispSwap_Color3bv(GLbyte * pc)
306{
307 glColor3bv((const GLbyte *) (pc + 0));
308}
309
310void
311__glXDispSwap_Color3dv(GLbyte * pc)
312{
313#ifdef __GLX_ALIGN641
314 if ((unsigned long) (pc) & 7) {
315 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
316 pc -= 4;
317 }
318#endif
319
320 glColor3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
321}
322
323void
324__glXDispSwap_Color3fv(GLbyte * pc)
325{
326 glColor3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
327}
328
329void
330__glXDispSwap_Color3iv(GLbyte * pc)
331{
332 glColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
333}
334
335void
336__glXDispSwap_Color3sv(GLbyte * pc)
337{
338 glColor3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
339}
340
341void
342__glXDispSwap_Color3ubv(GLbyte * pc)
343{
344 glColor3ubv((const GLubyte *) (pc + 0));
345}
346
347void
348__glXDispSwap_Color3uiv(GLbyte * pc)
349{
350 glColor3uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 3));
351}
352
353void
354__glXDispSwap_Color3usv(GLbyte * pc)
355{
356 glColor3usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 3));
357}
358
359void
360__glXDispSwap_Color4bv(GLbyte * pc)
361{
362 glColor4bv((const GLbyte *) (pc + 0));
363}
364
365void
366__glXDispSwap_Color4dv(GLbyte * pc)
367{
368#ifdef __GLX_ALIGN641
369 if ((unsigned long) (pc) & 7) {
370 (void) memmove(pc - 4, pc, 32)__builtin___memmove_chk (pc - 4, pc, 32, __builtin_object_size
(pc - 4, 0))
;
371 pc -= 4;
372 }
373#endif
374
375 glColor4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
376}
377
378void
379__glXDispSwap_Color4fv(GLbyte * pc)
380{
381 glColor4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
382}
383
384void
385__glXDispSwap_Color4iv(GLbyte * pc)
386{
387 glColor4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
388}
389
390void
391__glXDispSwap_Color4sv(GLbyte * pc)
392{
393 glColor4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
394}
395
396void
397__glXDispSwap_Color4ubv(GLbyte * pc)
398{
399 glColor4ubv((const GLubyte *) (pc + 0));
400}
401
402void
403__glXDispSwap_Color4uiv(GLbyte * pc)
404{
405 glColor4uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 4));
406}
407
408void
409__glXDispSwap_Color4usv(GLbyte * pc)
410{
411 glColor4usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 4));
412}
413
414void
415__glXDispSwap_EdgeFlagv(GLbyte * pc)
416{
417 glEdgeFlagv((const GLboolean *) (pc + 0));
418}
419
420void
421__glXDispSwap_End(GLbyte * pc)
422{
423 glEnd();
424}
425
426void
427__glXDispSwap_Indexdv(GLbyte * pc)
428{
429#ifdef __GLX_ALIGN641
430 if ((unsigned long) (pc) & 7) {
431 (void) memmove(pc - 4, pc, 8)__builtin___memmove_chk (pc - 4, pc, 8, __builtin_object_size
(pc - 4, 0))
;
432 pc -= 4;
433 }
434#endif
435
436 glIndexdv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
437}
438
439void
440__glXDispSwap_Indexfv(GLbyte * pc)
441{
442 glIndexfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
443}
444
445void
446__glXDispSwap_Indexiv(GLbyte * pc)
447{
448 glIndexiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1));
449}
450
451void
452__glXDispSwap_Indexsv(GLbyte * pc)
453{
454 glIndexsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1));
455}
456
457void
458__glXDispSwap_Normal3bv(GLbyte * pc)
459{
460 glNormal3bv((const GLbyte *) (pc + 0));
461}
462
463void
464__glXDispSwap_Normal3dv(GLbyte * pc)
465{
466#ifdef __GLX_ALIGN641
467 if ((unsigned long) (pc) & 7) {
468 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
469 pc -= 4;
470 }
471#endif
472
473 glNormal3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
474}
475
476void
477__glXDispSwap_Normal3fv(GLbyte * pc)
478{
479 glNormal3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
480}
481
482void
483__glXDispSwap_Normal3iv(GLbyte * pc)
484{
485 glNormal3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
486}
487
488void
489__glXDispSwap_Normal3sv(GLbyte * pc)
490{
491 glNormal3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
492}
493
494void
495__glXDispSwap_RasterPos2dv(GLbyte * pc)
496{
497#ifdef __GLX_ALIGN641
498 if ((unsigned long) (pc) & 7) {
499 (void) memmove(pc - 4, pc, 16)__builtin___memmove_chk (pc - 4, pc, 16, __builtin_object_size
(pc - 4, 0))
;
500 pc -= 4;
501 }
502#endif
503
504 glRasterPos2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
505}
506
507void
508__glXDispSwap_RasterPos2fv(GLbyte * pc)
509{
510 glRasterPos2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
511}
512
513void
514__glXDispSwap_RasterPos2iv(GLbyte * pc)
515{
516 glRasterPos2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
517}
518
519void
520__glXDispSwap_RasterPos2sv(GLbyte * pc)
521{
522 glRasterPos2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
523}
524
525void
526__glXDispSwap_RasterPos3dv(GLbyte * pc)
527{
528#ifdef __GLX_ALIGN641
529 if ((unsigned long) (pc) & 7) {
530 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
531 pc -= 4;
532 }
533#endif
534
535 glRasterPos3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
536}
537
538void
539__glXDispSwap_RasterPos3fv(GLbyte * pc)
540{
541 glRasterPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
542}
543
544void
545__glXDispSwap_RasterPos3iv(GLbyte * pc)
546{
547 glRasterPos3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
548}
549
550void
551__glXDispSwap_RasterPos3sv(GLbyte * pc)
552{
553 glRasterPos3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
554}
555
556void
557__glXDispSwap_RasterPos4dv(GLbyte * pc)
558{
559#ifdef __GLX_ALIGN641
560 if ((unsigned long) (pc) & 7) {
561 (void) memmove(pc - 4, pc, 32)__builtin___memmove_chk (pc - 4, pc, 32, __builtin_object_size
(pc - 4, 0))
;
562 pc -= 4;
563 }
564#endif
565
566 glRasterPos4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
567}
568
569void
570__glXDispSwap_RasterPos4fv(GLbyte * pc)
571{
572 glRasterPos4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
573}
574
575void
576__glXDispSwap_RasterPos4iv(GLbyte * pc)
577{
578 glRasterPos4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
579}
580
581void
582__glXDispSwap_RasterPos4sv(GLbyte * pc)
583{
584 glRasterPos4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
585}
586
587void
588__glXDispSwap_Rectdv(GLbyte * pc)
589{
590#ifdef __GLX_ALIGN641
591 if ((unsigned long) (pc) & 7) {
592 (void) memmove(pc - 4, pc, 32)__builtin___memmove_chk (pc - 4, pc, 32, __builtin_object_size
(pc - 4, 0))
;
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
601void
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
608void
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
615void
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
622void
623__glXDispSwap_TexCoord1dv(GLbyte * pc)
624{
625#ifdef __GLX_ALIGN641
626 if ((unsigned long) (pc) & 7) {
627 (void) memmove(pc - 4, pc, 8)__builtin___memmove_chk (pc - 4, pc, 8, __builtin_object_size
(pc - 4, 0))
;
628 pc -= 4;
629 }
630#endif
631
632 glTexCoord1dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
633}
634
635void
636__glXDispSwap_TexCoord1fv(GLbyte * pc)
637{
638 glTexCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
639}
640
641void
642__glXDispSwap_TexCoord1iv(GLbyte * pc)
643{
644 glTexCoord1iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1));
645}
646
647void
648__glXDispSwap_TexCoord1sv(GLbyte * pc)
649{
650 glTexCoord1sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1));
651}
652
653void
654__glXDispSwap_TexCoord2dv(GLbyte * pc)
655{
656#ifdef __GLX_ALIGN641
657 if ((unsigned long) (pc) & 7) {
658 (void) memmove(pc - 4, pc, 16)__builtin___memmove_chk (pc - 4, pc, 16, __builtin_object_size
(pc - 4, 0))
;
659 pc -= 4;
660 }
661#endif
662
663 glTexCoord2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
664}
665
666void
667__glXDispSwap_TexCoord2fv(GLbyte * pc)
668{
669 glTexCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
670}
671
672void
673__glXDispSwap_TexCoord2iv(GLbyte * pc)
674{
675 glTexCoord2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
676}
677
678void
679__glXDispSwap_TexCoord2sv(GLbyte * pc)
680{
681 glTexCoord2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
682}
683
684void
685__glXDispSwap_TexCoord3dv(GLbyte * pc)
686{
687#ifdef __GLX_ALIGN641
688 if ((unsigned long) (pc) & 7) {
689 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
690 pc -= 4;
691 }
692#endif
693
694 glTexCoord3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
695}
696
697void
698__glXDispSwap_TexCoord3fv(GLbyte * pc)
699{
700 glTexCoord3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
701}
702
703void
704__glXDispSwap_TexCoord3iv(GLbyte * pc)
705{
706 glTexCoord3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
707}
708
709void
710__glXDispSwap_TexCoord3sv(GLbyte * pc)
711{
712 glTexCoord3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
713}
714
715void
716__glXDispSwap_TexCoord4dv(GLbyte * pc)
717{
718#ifdef __GLX_ALIGN641
719 if ((unsigned long) (pc) & 7) {
720 (void) memmove(pc - 4, pc, 32)__builtin___memmove_chk (pc - 4, pc, 32, __builtin_object_size
(pc - 4, 0))
;
721 pc -= 4;
722 }
723#endif
724
725 glTexCoord4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
726}
727
728void
729__glXDispSwap_TexCoord4fv(GLbyte * pc)
730{
731 glTexCoord4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
732}
733
734void
735__glXDispSwap_TexCoord4iv(GLbyte * pc)
736{
737 glTexCoord4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
738}
739
740void
741__glXDispSwap_TexCoord4sv(GLbyte * pc)
742{
743 glTexCoord4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
744}
745
746void
747__glXDispSwap_Vertex2dv(GLbyte * pc)
748{
749#ifdef __GLX_ALIGN641
750 if ((unsigned long) (pc) & 7) {
751 (void) memmove(pc - 4, pc, 16)__builtin___memmove_chk (pc - 4, pc, 16, __builtin_object_size
(pc - 4, 0))
;
752 pc -= 4;
753 }
754#endif
755
756 glVertex2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
757}
758
759void
760__glXDispSwap_Vertex2fv(GLbyte * pc)
761{
762 glVertex2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
763}
764
765void
766__glXDispSwap_Vertex2iv(GLbyte * pc)
767{
768 glVertex2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
769}
770
771void
772__glXDispSwap_Vertex2sv(GLbyte * pc)
773{
774 glVertex2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
775}
776
777void
778__glXDispSwap_Vertex3dv(GLbyte * pc)
779{
780#ifdef __GLX_ALIGN641
781 if ((unsigned long) (pc) & 7) {
782 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
783 pc -= 4;
784 }
785#endif
786
787 glVertex3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
788}
789
790void
791__glXDispSwap_Vertex3fv(GLbyte * pc)
792{
793 glVertex3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
794}
795
796void
797__glXDispSwap_Vertex3iv(GLbyte * pc)
798{
799 glVertex3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
800}
801
802void
803__glXDispSwap_Vertex3sv(GLbyte * pc)
804{
805 glVertex3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
806}
807
808void
809__glXDispSwap_Vertex4dv(GLbyte * pc)
810{
811#ifdef __GLX_ALIGN641
812 if ((unsigned long) (pc) & 7) {
813 (void) memmove(pc - 4, pc, 32)__builtin___memmove_chk (pc - 4, pc, 32, __builtin_object_size
(pc - 4, 0))
;
814 pc -= 4;
815 }
816#endif
817
818 glVertex4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
819}
820
821void
822__glXDispSwap_Vertex4fv(GLbyte * pc)
823{
824 glVertex4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
825}
826
827void
828__glXDispSwap_Vertex4iv(GLbyte * pc)
829{
830 glVertex4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
831}
832
833void
834__glXDispSwap_Vertex4sv(GLbyte * pc)
835{
836 glVertex4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
837}
838
839void
840__glXDispSwap_ClipPlane(GLbyte * pc)
841{
842#ifdef __GLX_ALIGN641
843 if ((unsigned long) (pc) & 7) {
844 (void) memmove(pc - 4, pc, 36)__builtin___memmove_chk (pc - 4, pc, 36, __builtin_object_size
(pc - 4, 0))
;
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
853void
854__glXDispSwap_ColorMaterial(GLbyte * pc)
855{
856 glColorMaterial((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
857}
858
859void
860__glXDispSwap_CullFace(GLbyte * pc)
861{
862 glCullFace((GLenum) bswap_ENUM(pc + 0));
863}
864
865void
866__glXDispSwap_Fogf(GLbyte * pc)
867{
868 glFogf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
869}
870
871void
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
884void
885__glXDispSwap_Fogi(GLbyte * pc)
886{
887 glFogi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
888}
889
890void
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
903void
904__glXDispSwap_FrontFace(GLbyte * pc)
905{
906 glFrontFace((GLenum) bswap_ENUM(pc + 0));
907}
908
909void
910__glXDispSwap_Hint(GLbyte * pc)
911{
912 glHint((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
913}
914
915void
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
922void
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
935void
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
942void
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
955void
956__glXDispSwap_LightModelf(GLbyte * pc)
957{
958 glLightModelf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
959}
960
961void
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
974void
975__glXDispSwap_LightModeli(GLbyte * pc)
976{
977 glLightModeli((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
978}
979
980void
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
993void
994__glXDispSwap_LineStipple(GLbyte * pc)
995{
996 glLineStipple((GLint) bswap_CARD32(pc + 0),
997 (GLushort) bswap_CARD16(pc + 4));
998}
999
1000void
1001__glXDispSwap_LineWidth(GLbyte * pc)
1002{
1003 glLineWidth((GLfloat) bswap_FLOAT32(pc + 0));
1004}
1005
1006void
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
1013void
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
1026void
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
1033void
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
1046void
1047__glXDispSwap_PointSize(GLbyte * pc)
1048{
1049 glPointSize((GLfloat) bswap_FLOAT32(pc + 0));
1050}
1051
1052void
1053__glXDispSwap_PolygonMode(GLbyte * pc)
1054{
1055 glPolygonMode((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
1056}
1057
1058void
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_FIRST0x0CF1, hdr->lsbFirst);
1065 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
1066 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
1067 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
1068 (GLint) bswap_CARD32(&hdr->skipPixels));
1069 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (GLint) bswap_CARD32(&hdr->alignment));
1070
1071 glPolygonStipple(mask);
1072}
1073
1074void
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
1082void
1083__glXDispSwap_ShadeModel(GLbyte * pc)
1084{
1085 glShadeModel((GLenum) bswap_ENUM(pc + 0));
1086}
1087
1088void
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
1096void
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
1109void
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
1116void
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
1129void
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_BYTES0x0CF0, hdr->swapBytes);
1136 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
1137 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
1138 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
1139 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
1140 (GLint) bswap_CARD32(&hdr->skipPixels));
1141 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
1152void
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_BYTES0x0CF0, hdr->swapBytes);
1159 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
1160 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
1161 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
1162 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
1163 (GLint) bswap_CARD32(&hdr->skipPixels));
1164 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
1176void
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
1183void
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
1196void
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
1203void
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
1216void
1217__glXDispSwap_TexGend(GLbyte * pc)
1218{
1219#ifdef __GLX_ALIGN641
1220 if ((unsigned long) (pc) & 7) {
1221 (void) memmove(pc - 4, pc, 16)__builtin___memmove_chk (pc - 4, pc, 16, __builtin_object_size
(pc - 4, 0))
;
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
1230void
1231__glXDispSwap_TexGendv(GLbyte * pc)
1232{
1233 const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
1234 const GLdouble *params;
1235
1236#ifdef __GLX_ALIGN641
1237 const GLuint compsize = __glTexGendv_size(pname);
1238 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8))((((compsize * 8)) + 3) & ~3) - 4;
1239
1240 if ((unsigned long) (pc) & 7) {
1241 (void) memmove(pc - 4, pc, cmdlen)__builtin___memmove_chk (pc - 4, pc, cmdlen, __builtin_object_size
(pc - 4, 0))
;
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
1253void
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
1260void
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
1273void
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
1280void
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
1293void
1294__glXDispSwap_InitNames(GLbyte * pc)
1295{
1296 glInitNames();
1297}
1298
1299void
1300__glXDispSwap_LoadName(GLbyte * pc)
1301{
1302 glLoadName((GLuint) bswap_CARD32(pc + 0));
1303}
1304
1305void
1306__glXDispSwap_PassThrough(GLbyte * pc)
1307{
1308 glPassThrough((GLfloat) bswap_FLOAT32(pc + 0));
1309}
1310
1311void
1312__glXDispSwap_PopName(GLbyte * pc)
1313{
1314 glPopName();
1315}
1316
1317void
1318__glXDispSwap_PushName(GLbyte * pc)
1319{
1320 glPushName((GLuint) bswap_CARD32(pc + 0));
1321}
1322
1323void
1324__glXDispSwap_DrawBuffer(GLbyte * pc)
1325{
1326 glDrawBuffer((GLenum) bswap_ENUM(pc + 0));
1327}
1328
1329void
1330__glXDispSwap_Clear(GLbyte * pc)
1331{
1332 glClear((GLbitfield) bswap_CARD32(pc + 0));
1333}
1334
1335void
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
1344void
1345__glXDispSwap_ClearIndex(GLbyte * pc)
1346{
1347 glClearIndex((GLfloat) bswap_FLOAT32(pc + 0));
1348}
1349
1350void
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
1359void
1360__glXDispSwap_ClearStencil(GLbyte * pc)
1361{
1362 glClearStencil((GLint) bswap_CARD32(pc + 0));
1363}
1364
1365void
1366__glXDispSwap_ClearDepth(GLbyte * pc)
1367{
1368#ifdef __GLX_ALIGN641
1369 if ((unsigned long) (pc) & 7) {
1370 (void) memmove(pc - 4, pc, 8)__builtin___memmove_chk (pc - 4, pc, 8, __builtin_object_size
(pc - 4, 0))
;
1371 pc -= 4;
1372 }
1373#endif
1374
1375 glClearDepth((GLclampd) bswap_FLOAT64(pc + 0));
1376}
1377
1378void
1379__glXDispSwap_StencilMask(GLbyte * pc)
1380{
1381 glStencilMask((GLuint) bswap_CARD32(pc + 0));
1382}
1383
1384void
1385__glXDispSwap_ColorMask(GLbyte * pc)
1386{
1387 glColorMask(*(GLboolean *) (pc + 0),
1388 *(GLboolean *) (pc + 1),
1389 *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3));
1390}
1391
1392void
1393__glXDispSwap_DepthMask(GLbyte * pc)
1394{
1395 glDepthMask(*(GLboolean *) (pc + 0));
1396}
1397
1398void
1399__glXDispSwap_IndexMask(GLbyte * pc)
1400{
1401 glIndexMask((GLuint) bswap_CARD32(pc + 0));
1402}
1403
1404void
1405__glXDispSwap_Accum(GLbyte * pc)
1406{
1407 glAccum((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
1408}
1409
1410void
1411__glXDispSwap_Disable(GLbyte * pc)
1412{
1413 glDisable((GLenum) bswap_ENUM(pc + 0));
1414}
1415
1416void
1417__glXDispSwap_Enable(GLbyte * pc)
1418{
1419 glEnable((GLenum) bswap_ENUM(pc + 0));
1420}
1421
1422void
1423__glXDispSwap_PopAttrib(GLbyte * pc)
1424{
1425 glPopAttrib();
1426}
1427
1428void
1429__glXDispSwap_PushAttrib(GLbyte * pc)
1430{
1431 glPushAttrib((GLbitfield) bswap_CARD32(pc + 0));
1432}
1433
1434void
1435__glXDispSwap_MapGrid1d(GLbyte * pc)
1436{
1437#ifdef __GLX_ALIGN641
1438 if ((unsigned long) (pc) & 7) {
1439 (void) memmove(pc - 4, pc, 20)__builtin___memmove_chk (pc - 4, pc, 20, __builtin_object_size
(pc - 4, 0))
;
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
1449void
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
1457void
1458__glXDispSwap_MapGrid2d(GLbyte * pc)
1459{
1460#ifdef __GLX_ALIGN641
1461 if ((unsigned long) (pc) & 7) {
1462 (void) memmove(pc - 4, pc, 40)__builtin___memmove_chk (pc - 4, pc, 40, __builtin_object_size
(pc - 4, 0))
;
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
1475void
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
1486void
1487__glXDispSwap_EvalCoord1dv(GLbyte * pc)
1488{
1489#ifdef __GLX_ALIGN641
1490 if ((unsigned long) (pc) & 7) {
1491 (void) memmove(pc - 4, pc, 8)__builtin___memmove_chk (pc - 4, pc, 8, __builtin_object_size
(pc - 4, 0))
;
1492 pc -= 4;
1493 }
1494#endif
1495
1496 glEvalCoord1dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
1497}
1498
1499void
1500__glXDispSwap_EvalCoord1fv(GLbyte * pc)
1501{
1502 glEvalCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
1503}
1504
1505void
1506__glXDispSwap_EvalCoord2dv(GLbyte * pc)
1507{
1508#ifdef __GLX_ALIGN641
1509 if ((unsigned long) (pc) & 7) {
1510 (void) memmove(pc - 4, pc, 16)__builtin___memmove_chk (pc - 4, pc, 16, __builtin_object_size
(pc - 4, 0))
;
1511 pc -= 4;
1512 }
1513#endif
1514
1515 glEvalCoord2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
1516}
1517
1518void
1519__glXDispSwap_EvalCoord2fv(GLbyte * pc)
1520{
1521 glEvalCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
1522}
1523
1524void
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
1531void
1532__glXDispSwap_EvalPoint1(GLbyte * pc)
1533{
1534 glEvalPoint1((GLint) bswap_CARD32(pc + 0));
1535}
1536
1537void
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
1546void
1547__glXDispSwap_EvalPoint2(GLbyte * pc)
1548{
1549 glEvalPoint2((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4));
1550}
1551
1552void
1553__glXDispSwap_AlphaFunc(GLbyte * pc)
1554{
1555 glAlphaFunc((GLenum) bswap_ENUM(pc + 0), (GLclampf) bswap_FLOAT32(pc + 4));
1556}
1557
1558void
1559__glXDispSwap_BlendFunc(GLbyte * pc)
1560{
1561 glBlendFunc((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
1562}
1563
1564void
1565__glXDispSwap_LogicOp(GLbyte * pc)
1566{
1567 glLogicOp((GLenum) bswap_ENUM(pc + 0));
1568}
1569
1570void
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
1577void
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
1584void
1585__glXDispSwap_DepthFunc(GLbyte * pc)
1586{
1587 glDepthFunc((GLenum) bswap_ENUM(pc + 0));
1588}
1589
1590void
1591__glXDispSwap_PixelZoom(GLbyte * pc)
1592{
1593 glPixelZoom((GLfloat) bswap_FLOAT32(pc + 0),
1594 (GLfloat) bswap_FLOAT32(pc + 4));
1595}
1596
1597void
1598__glXDispSwap_PixelTransferf(GLbyte * pc)
1599{
1600 glPixelTransferf((GLenum) bswap_ENUM(pc + 0),
1601 (GLfloat) bswap_FLOAT32(pc + 4));
1602}
1603
1604void
1605__glXDispSwap_PixelTransferi(GLbyte * pc)
1606{
1607 glPixelTransferi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
1608}
1609
1610int
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_SIZE8;
1619 if (cx != NULL((void*)0)) {
1620 glPixelStoref((GLenum) bswap_ENUM(pc + 0),
1621 (GLfloat) bswap_FLOAT32(pc + 4));
1622 error = Success0;
1623 }
1624
1625 return error;
1626}
1627
1628int
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_SIZE8;
1637 if (cx != NULL((void*)0)) {
1638 glPixelStorei((GLenum) bswap_ENUM(pc + 0),
1639 (GLint) bswap_CARD32(pc + 4));
1640 error = Success0;
1641 }
1642
1643 return error;
1644}
1645
1646void
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
1656void
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
1666void
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
1676void
1677__glXDispSwap_ReadBuffer(GLbyte * pc)
1678{
1679 glReadBuffer((GLenum) bswap_ENUM(pc + 0));
1680}
1681
1682void
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
1691void
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_BYTES0x0CF0, hdr->swapBytes);
1698 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
1699 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
1700 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
1701 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
1702 (GLint) bswap_CARD32(&hdr->skipPixels));
1703 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
1711int
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_SIZE8;
1720 if (cx != NULL((void*)0)) {
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((void*)0))
1730 return BadAlloc11;
1731 __glXClearErrorOccured();
1732
1733 glGetBooleanv(pname, params);
1734 __glXSendReplySwap(cl->client, params, compsize, 1, GL_FALSE0x0, 0);
1735 error = Success0;
1736 }
1737
1738 return error;
1739}
1740
1741int
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_SIZE8;
1750 if (cx != NULL((void*)0)) {
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_TRUE0x1, 0);
1756 error = Success0;
1757 }
1758
1759 return error;
1760}
1761
1762int
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_SIZE8;
1771 if (cx != NULL((void*)0)) {
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((void*)0))
1781 return BadAlloc11;
1782 __glXClearErrorOccured();
1783
1784 glGetDoublev(pname, params);
1785 (void) bswap_64_array((uint64_t *) params, compsize);
1786 __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE0x0, 0);
1787 error = Success0;
1788 }
1789
1790 return error;
1791}
1792
1793int
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_SIZE8;
Value stored to 'pc' is never read
1802 if (cx != NULL((void*)0)) {
1803 GLenum retval;
1804
1805 retval = glGetError();
1806 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
1807 error = Success0;
1808 }
1809
1810 return error;
1811}
1812
1813int
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_SIZE8;
1822 if (cx != NULL((void*)0)) {
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((void*)0))
1832 return BadAlloc11;
1833 __glXClearErrorOccured();
1834
1835 glGetFloatv(pname, params);
1836 (void) bswap_32_array((uint32_t *) params, compsize);
1837 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE0x0, 0);
1838 error = Success0;
1839 }
1840
1841 return error;
1842}
1843
1844int
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_SIZE8;
1853 if (cx != NULL((void*)0)) {
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((void*)0))
1863 return BadAlloc11;
1864 __glXClearErrorOccured();
1865
1866 glGetIntegerv(pname, params);
1867 (void) bswap_32_array((uint32_t *) params, compsize);
1868 __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE0x0, 0);
1869 error = Success0;
1870 }
1871
1872 return error;
1873}
1874
1875int
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_SIZE8;
1884 if (cx != NULL((void*)0)) {
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((void*)0))
1894 return BadAlloc11;
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_FALSE0x0, 0);
1900 error = Success0;
1901 }
1902
1903 return error;
1904}
1905
1906int
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_SIZE8;
1915 if (cx != NULL((void*)0)) {
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((void*)0))
1925 return BadAlloc11;
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_FALSE0x0, 0);
1931 error = Success0;
1932 }
1933
1934 return error;
1935}
1936
1937int
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_SIZE8;
1946 if (cx != NULL((void*)0)) {
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((void*)0))
1957 return BadAlloc11;
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_FALSE0x0, 0);
1963 error = Success0;
1964 }
1965
1966 return error;
1967}
1968
1969int
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_SIZE8;
1978 if (cx != NULL((void*)0)) {
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((void*)0))
1989 return BadAlloc11;
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_FALSE0x0, 0);
1995 error = Success0;
1996 }
1997
1998 return error;
1999}
2000
2001int
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_SIZE8;
2010 if (cx != NULL((void*)0)) {
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((void*)0))
2021 return BadAlloc11;
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_FALSE0x0, 0);
2027 error = Success0;
2028 }
2029
2030 return error;
2031}
2032
2033int
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_SIZE8;
2042 if (cx != NULL((void*)0)) {
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((void*)0))
2052 return BadAlloc11;
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_FALSE0x0, 0);
2058 error = Success0;
2059 }
2060
2061 return error;
2062}
2063
2064int
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_SIZE8;
2073 if (cx != NULL((void*)0)) {
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((void*)0))
2083 return BadAlloc11;
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_FALSE0x0, 0);
2089 error = Success0;
2090 }
2091
2092 return error;
2093}
2094
2095int
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_SIZE8;
2104 if (cx != NULL((void*)0)) {
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((void*)0))
2114 return BadAlloc11;
2115 __glXClearErrorOccured();
2116
2117 glGetPixelMapfv(map, values);
2118 (void) bswap_32_array((uint32_t *) values, compsize);
2119 __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE0x0, 0);
2120 error = Success0;
2121 }
2122
2123 return error;
2124}
2125
2126int
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_SIZE8;
2135 if (cx != NULL((void*)0)) {
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((void*)0))
2145 return BadAlloc11;
2146 __glXClearErrorOccured();
2147
2148 glGetPixelMapuiv(map, values);
2149 (void) bswap_32_array((uint32_t *) values, compsize);
2150 __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE0x0, 0);
2151 error = Success0;
2152 }
2153
2154 return error;
2155}
2156
2157int
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_SIZE8;
2166 if (cx != NULL((void*)0)) {
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((void*)0))
2176 return BadAlloc11;
2177 __glXClearErrorOccured();
2178
2179 glGetPixelMapusv(map, values);
2180 (void) bswap_16_array((uint16_t *) values, compsize);
2181 __glXSendReplySwap(cl->client, values, compsize, 2, GL_FALSE0x0, 0);
2182 error = Success0;
2183 }
2184
2185 return error;
2186}
2187
2188int
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_SIZE8;
2197 if (cx != NULL((void*)0)) {
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((void*)0))
2207 return BadAlloc11;
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_FALSE0x0, 0);
2213 error = Success0;
2214 }
2215
2216 return error;
2217}
2218
2219int
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_SIZE8;
2228 if (cx != NULL((void*)0)) {
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((void*)0))
2238 return BadAlloc11;
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_FALSE0x0, 0);
2244 error = Success0;
2245 }
2246
2247 return error;
2248}
2249
2250int
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_SIZE8;
2259 if (cx != NULL((void*)0)) {
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((void*)0))
2269 return BadAlloc11;
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_FALSE0x0, 0);
2275 error = Success0;
2276 }
2277
2278 return error;
2279}
2280
2281int
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_SIZE8;
2290 if (cx != NULL((void*)0)) {
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((void*)0))
2300 return BadAlloc11;
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_FALSE0x0, 0);
2306 error = Success0;
2307 }
2308
2309 return error;
2310}
2311
2312int
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_SIZE8;
2321 if (cx != NULL((void*)0)) {
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((void*)0))
2331 return BadAlloc11;
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_FALSE0x0, 0);
2337 error = Success0;
2338 }
2339
2340 return error;
2341}
2342
2343int
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_SIZE8;
2352 if (cx != NULL((void*)0)) {
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((void*)0))
2362 return BadAlloc11;
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_FALSE0x0, 0);
2368 error = Success0;
2369 }
2370
2371 return error;
2372}
2373
2374int
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_SIZE8;
2383 if (cx != NULL((void*)0)) {
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((void*)0))
2393 return BadAlloc11;
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_FALSE0x0, 0);
2399 error = Success0;
2400 }
2401
2402 return error;
2403}
2404
2405int
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_SIZE8;
2414 if (cx != NULL((void*)0)) {
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((void*)0))
2424 return BadAlloc11;
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_FALSE0x0, 0);
2431 error = Success0;
2432 }
2433
2434 return error;
2435}
2436
2437int
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_SIZE8;
2446 if (cx != NULL((void*)0)) {
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((void*)0))
2456 return BadAlloc11;
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_FALSE0x0, 0);
2463 error = Success0;
2464 }
2465
2466 return error;
2467}
2468
2469int
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_SIZE8;
2478 if (cx != NULL((void*)0)) {
2479 GLboolean retval;
2480
2481 retval = glIsEnabled((GLenum) bswap_ENUM(pc + 0));
2482 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
2483 error = Success0;
2484 }
2485
2486 return error;
2487}
2488
2489int
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_SIZE8;
2498 if (cx != NULL((void*)0)) {
2499 GLboolean retval;
2500
2501 retval = glIsList((GLuint) bswap_CARD32(pc + 0));
2502 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
2503 error = Success0;
2504 }
2505
2506 return error;
2507}
2508
2509void
2510__glXDispSwap_DepthRange(GLbyte * pc)
2511{
2512#ifdef __GLX_ALIGN641
2513 if ((unsigned long) (pc) & 7) {
2514 (void) memmove(pc - 4, pc, 16)__builtin___memmove_chk (pc - 4, pc, 16, __builtin_object_size
(pc - 4, 0))
;
2515 pc -= 4;
2516 }
2517#endif
2518
2519 glDepthRange((GLclampd) bswap_FLOAT64(pc + 0),
2520 (GLclampd) bswap_FLOAT64(pc + 8));
2521}
2522
2523void
2524__glXDispSwap_Frustum(GLbyte * pc)
2525{
2526#ifdef __GLX_ALIGN641
2527 if ((unsigned long) (pc) & 7) {
2528 (void) memmove(pc - 4, pc, 48)__builtin___memmove_chk (pc - 4, pc, 48, __builtin_object_size
(pc - 4, 0))
;
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
2541void
2542__glXDispSwap_LoadIdentity(GLbyte * pc)
2543{
2544 glLoadIdentity();
2545}
2546
2547void
2548__glXDispSwap_LoadMatrixf(GLbyte * pc)
2549{
2550 glLoadMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16));
2551}
2552
2553void
2554__glXDispSwap_LoadMatrixd(GLbyte * pc)
2555{
2556#ifdef __GLX_ALIGN641
2557 if ((unsigned long) (pc) & 7) {
2558 (void) memmove(pc - 4, pc, 128)__builtin___memmove_chk (pc - 4, pc, 128, __builtin_object_size
(pc - 4, 0))
;
2559 pc -= 4;
2560 }
2561#endif
2562
2563 glLoadMatrixd((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 16));
2564}
2565
2566void
2567__glXDispSwap_MatrixMode(GLbyte * pc)
2568{
2569 glMatrixMode((GLenum) bswap_ENUM(pc + 0));
2570}
2571
2572void
2573__glXDispSwap_MultMatrixf(GLbyte * pc)
2574{
2575 glMultMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16));
2576}
2577
2578void
2579__glXDispSwap_MultMatrixd(GLbyte * pc)
2580{
2581#ifdef __GLX_ALIGN641
2582 if ((unsigned long) (pc) & 7) {
2583 (void) memmove(pc - 4, pc, 128)__builtin___memmove_chk (pc - 4, pc, 128, __builtin_object_size
(pc - 4, 0))
;
2584 pc -= 4;
2585 }
2586#endif
2587
2588 glMultMatrixd((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 16));
2589}
2590
2591void
2592__glXDispSwap_Ortho(GLbyte * pc)
2593{
2594#ifdef __GLX_ALIGN641
2595 if ((unsigned long) (pc) & 7) {
2596 (void) memmove(pc - 4, pc, 48)__builtin___memmove_chk (pc - 4, pc, 48, __builtin_object_size
(pc - 4, 0))
;
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
2609void
2610__glXDispSwap_PopMatrix(GLbyte * pc)
2611{
2612 glPopMatrix();
2613}
2614
2615void
2616__glXDispSwap_PushMatrix(GLbyte * pc)
2617{
2618 glPushMatrix();
2619}
2620
2621void
2622__glXDispSwap_Rotated(GLbyte * pc)
2623{
2624#ifdef __GLX_ALIGN641
2625 if ((unsigned long) (pc) & 7) {
2626 (void) memmove(pc - 4, pc, 32)__builtin___memmove_chk (pc - 4, pc, 32, __builtin_object_size
(pc - 4, 0))
;
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
2637void
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
2646void
2647__glXDispSwap_Scaled(GLbyte * pc)
2648{
2649#ifdef __GLX_ALIGN641
2650 if ((unsigned long) (pc) & 7) {
2651 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
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
2661void
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
2668void
2669__glXDispSwap_Translated(GLbyte * pc)
2670{
2671#ifdef __GLX_ALIGN641
2672 if ((unsigned long) (pc) & 7) {
2673 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
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
2683void
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
2691void
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
2699void
2700__glXDispSwap_BindTexture(GLbyte * pc)
2701{
2702 glBindTexture((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
2703}
2704
2705void
2706__glXDispSwap_Indexubv(GLbyte * pc)
2707{
2708 glIndexubv((const GLubyte *) (pc + 0));
2709}
2710
2711void
2712__glXDispSwap_PolygonOffset(GLbyte * pc)
2713{
2714 glPolygonOffset((GLfloat) bswap_FLOAT32(pc + 0),
2715 (GLfloat) bswap_FLOAT32(pc + 4));
2716}
2717
2718int
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_SIZE8;
2727 if (cx != NULL((void*)0)) {
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((void*)0))
2736 return BadAlloc11;
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_TRUE0x1, retval);
2743 error = Success0;
2744 }
2745
2746 return error;
2747}
2748
2749int
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_SIZE12;
2758 if (cx != NULL((void*)0)) {
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((void*)0))
2767 return BadAlloc11;
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_TRUE0x1, retval);
2774 error = Success0;
2775 }
2776
2777 return error;
2778}
2779
2780void
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
2792void
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
2805void
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
2816void
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
2829int
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_SIZE8;
2838 if (cx != NULL((void*)0)) {
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 = Success0;
2845 }
2846
2847 return error;
2848}
2849
2850int
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_SIZE12;
2859 if (cx != NULL((void*)0)) {
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 = Success0;
2866 }
2867
2868 return error;
2869}
2870
2871int
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_SIZE8;
2880 if (cx != NULL((void*)0)) {
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((void*)0))
2889 return BadAlloc11;
2890 glGenTextures(n, textures);
2891 (void) bswap_32_array((uint32_t *) textures, n);
2892 __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE0x1, 0);
2893 error = Success0;
2894 }
2895
2896 return error;
2897}
2898
2899int
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_SIZE12;
2908 if (cx != NULL((void*)0)) {
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((void*)0))
2917 return BadAlloc11;
2918 glGenTextures(n, textures);
2919 (void) bswap_32_array((uint32_t *) textures, n);
2920 __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE0x1, 0);
2921 error = Success0;
2922 }
2923
2924 return error;
2925}
2926
2927int
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_SIZE8;
2936 if (cx != NULL((void*)0)) {
2937 GLboolean retval;
2938
2939 retval = glIsTexture((GLuint) bswap_CARD32(pc + 0));
2940 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
2941 error = Success0;
2942 }
2943
2944 return error;
2945}
2946
2947int
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_SIZE12;
2956 if (cx != NULL((void*)0)) {
2957 GLboolean retval;
2958
2959 retval = glIsTexture((GLuint) bswap_CARD32(pc + 0));
2960 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
2961 error = Success0;
2962 }
2963
2964 return error;
2965}
2966
2967void
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
2979void
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_BYTES0x0CF0, hdr->swapBytes);
2986 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
2987 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
2988 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
2989 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
2990 (GLint) bswap_CARD32(&hdr->skipPixels));
2991 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3001void
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_BYTES0x0CF0, hdr->swapBytes);
3008 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3009 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3010 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3011 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3012 (GLint) bswap_CARD32(&hdr->skipPixels));
3013 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3025void
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
3034void
3035__glXDispSwap_BlendEquation(GLbyte * pc)
3036{
3037 glBlendEquation((GLenum) bswap_ENUM(pc + 0));
3038}
3039
3040void
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_BYTES0x0CF0, hdr->swapBytes);
3047 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3048 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3049 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3050 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3051 (GLint) bswap_CARD32(&hdr->skipPixels));
3052 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3061void
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
3074void
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
3087void
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
3097int
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_SIZE8;
3106 if (cx != NULL((void*)0)) {
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((void*)0))
3116 return BadAlloc11;
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_FALSE0x0, 0);
3122 error = Success0;
3123 }
3124
3125 return error;
3126}
3127
3128int
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_SIZE12;
3137 if (cx != NULL((void*)0)) {
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((void*)0))
3147 return BadAlloc11;
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_FALSE0x0, 0);
3153 error = Success0;
3154 }
3155
3156 return error;
3157}
3158
3159int
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_SIZE8;
3168 if (cx != NULL((void*)0)) {
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((void*)0))
3178 return BadAlloc11;
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_FALSE0x0, 0);
3184 error = Success0;
3185 }
3186
3187 return error;
3188}
3189
3190int
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_SIZE12;
3199 if (cx != NULL((void*)0)) {
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((void*)0))
3209 return BadAlloc11;
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_FALSE0x0, 0);
3215 error = Success0;
3216 }
3217
3218 return error;
3219}
3220
3221void
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_BYTES0x0CF0, hdr->swapBytes);
3228 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3229 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3230 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3231 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3232 (GLint) bswap_CARD32(&hdr->skipPixels));
3233 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3242void
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
3252void
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_BYTES0x0CF0, hdr->swapBytes);
3259 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3260 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3261 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3262 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3263 (GLint) bswap_CARD32(&hdr->skipPixels));
3264 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3273void
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_BYTES0x0CF0, hdr->swapBytes);
3280 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3281 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3282 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3283 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3284 (GLint) bswap_CARD32(&hdr->skipPixels));
3285 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3295void
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
3303void
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
3317void
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
3325void
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
3338void
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
3348void
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
3359int
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_SIZE8;
3368 if (cx != NULL((void*)0)) {
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((void*)0))
3378 return BadAlloc11;
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_FALSE0x0, 0);
3384 error = Success0;
3385 }
3386
3387 return error;
3388}
3389
3390int
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_SIZE12;
3399 if (cx != NULL((void*)0)) {
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((void*)0))
3409 return BadAlloc11;
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_FALSE0x0, 0);
3415 error = Success0;
3416 }
3417
3418 return error;
3419}
3420
3421int
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_SIZE8;
3430 if (cx != NULL((void*)0)) {
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((void*)0))
3440 return BadAlloc11;
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_FALSE0x0, 0);
3446 error = Success0;
3447 }
3448
3449 return error;
3450}
3451
3452int
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_SIZE12;
3461 if (cx != NULL((void*)0)) {
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((void*)0))
3471 return BadAlloc11;
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_FALSE0x0, 0);
3477 error = Success0;
3478 }
3479
3480 return error;
3481}
3482
3483int
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_SIZE8;
3492 if (cx != NULL((void*)0)) {
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((void*)0))
3502 return BadAlloc11;
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_FALSE0x0, 0);
3508 error = Success0;
3509 }
3510
3511 return error;
3512}
3513
3514int
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_SIZE12;
3523 if (cx != NULL((void*)0)) {
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((void*)0))
3533 return BadAlloc11;
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_FALSE0x0, 0);
3539 error = Success0;
3540 }
3541
3542 return error;
3543}
3544
3545int
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_SIZE8;
3554 if (cx != NULL((void*)0)) {
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((void*)0))
3564 return BadAlloc11;
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_FALSE0x0, 0);
3570 error = Success0;
3571 }
3572
3573 return error;
3574}
3575
3576int
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_SIZE12;
3585 if (cx != NULL((void*)0)) {
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((void*)0))
3595 return BadAlloc11;
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_FALSE0x0, 0);
3601 error = Success0;
3602 }
3603
3604 return error;
3605}
3606
3607int
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_SIZE8;
3616 if (cx != NULL((void*)0)) {
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((void*)0))
3626 return BadAlloc11;
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_FALSE0x0, 0);
3632 error = Success0;
3633 }
3634
3635 return error;
3636}
3637
3638int
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_SIZE12;
3647 if (cx != NULL((void*)0)) {
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((void*)0))
3657 return BadAlloc11;
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_FALSE0x0, 0);
3663 error = Success0;
3664 }
3665
3666 return error;
3667}
3668
3669int
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_SIZE8;
3678 if (cx != NULL((void*)0)) {
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((void*)0))
3688 return BadAlloc11;
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_FALSE0x0, 0);
3694 error = Success0;
3695 }
3696
3697 return error;
3698}
3699
3700int
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_SIZE12;
3709 if (cx != NULL((void*)0)) {
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((void*)0))
3719 return BadAlloc11;
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_FALSE0x0, 0);
3725 error = Success0;
3726 }
3727
3728 return error;
3729}
3730
3731void
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
3739void
3740__glXDispSwap_Minmax(GLbyte * pc)
3741{
3742 glMinmax((GLenum) bswap_ENUM(pc + 0),
3743 (GLenum) bswap_ENUM(pc + 4), *(GLboolean *) (pc + 8));
3744}
3745
3746void
3747__glXDispSwap_ResetHistogram(GLbyte * pc)
3748{
3749 glResetHistogram((GLenum) bswap_ENUM(pc + 0));
3750}
3751
3752void
3753__glXDispSwap_ResetMinmax(GLbyte * pc)
3754{
3755 glResetMinmax((GLenum) bswap_ENUM(pc + 0));
3756}
3757
3758void
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((void*)0) : (pc + 80));
3764 __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
3765
3766 glPixelStorei(GL_UNPACK_SWAP_BYTES0x0CF0, hdr->swapBytes);
3767 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3768 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3769 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT0x806E,
3770 (GLint) bswap_CARD32(&hdr->imageHeight));
3771 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3772 glPixelStorei(GL_UNPACK_SKIP_IMAGES0x806D,
3773 (GLint) bswap_CARD32(&hdr->skipImages));
3774 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3775 (GLint) bswap_CARD32(&hdr->skipPixels));
3776 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3789void
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_BYTES0x0CF0, hdr->swapBytes);
3796 glPixelStorei(GL_UNPACK_LSB_FIRST0x0CF1, hdr->lsbFirst);
3797 glPixelStorei(GL_UNPACK_ROW_LENGTH0x0CF2, (GLint) bswap_CARD32(&hdr->rowLength));
3798 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT0x806E,
3799 (GLint) bswap_CARD32(&hdr->imageHeight));
3800 glPixelStorei(GL_UNPACK_SKIP_ROWS0x0CF3, (GLint) bswap_CARD32(&hdr->skipRows));
3801 glPixelStorei(GL_UNPACK_SKIP_IMAGES0x806D,
3802 (GLint) bswap_CARD32(&hdr->skipImages));
3803 glPixelStorei(GL_UNPACK_SKIP_PIXELS0x0CF4,
3804 (GLint) bswap_CARD32(&hdr->skipPixels));
3805 glPixelStorei(GL_UNPACK_ALIGNMENT0x0CF5, (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
3819void
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
3833void
3834__glXDispSwap_ActiveTexture(GLbyte * pc)
3835{
3836 glActiveTextureARB((GLenum) bswap_ENUM(pc + 0));
3837}
3838
3839void
3840__glXDispSwap_MultiTexCoord1dv(GLbyte * pc)
3841{
3842#ifdef __GLX_ALIGN641
3843 if ((unsigned long) (pc) & 7) {
3844 (void) memmove(pc - 4, pc, 12)__builtin___memmove_chk (pc - 4, pc, 12, __builtin_object_size
(pc - 4, 0))
;
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
3854void
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
3862void
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
3870void
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
3878void
3879__glXDispSwap_MultiTexCoord2dv(GLbyte * pc)
3880{
3881#ifdef __GLX_ALIGN641
3882 if ((unsigned long) (pc) & 7) {
3883 (void) memmove(pc - 4, pc, 20)__builtin___memmove_chk (pc - 4, pc, 20, __builtin_object_size
(pc - 4, 0))
;
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
3893void
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
3901void
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
3909void
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
3917void
3918__glXDispSwap_MultiTexCoord3dv(GLbyte * pc)
3919{
3920#ifdef __GLX_ALIGN641
3921 if ((unsigned long) (pc) & 7) {
3922 (void) memmove(pc - 4, pc, 28)__builtin___memmove_chk (pc - 4, pc, 28, __builtin_object_size
(pc - 4, 0))
;
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
3932void
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
3940void
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
3948void
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
3956void
3957__glXDispSwap_MultiTexCoord4dv(GLbyte * pc)
3958{
3959#ifdef __GLX_ALIGN641
3960 if ((unsigned long) (pc) & 7) {
3961 (void) memmove(pc - 4, pc, 36)__builtin___memmove_chk (pc - 4, pc, 36, __builtin_object_size
(pc - 4, 0))
;
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
3971void
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
3979void
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
3987void
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
3995void
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
4010void
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
4026void
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
4043void
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
4058void
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
4075void
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
4094void
4095__glXDispSwap_SampleCoverage(GLbyte * pc)
4096{
4097 PFNGLSAMPLECOVERAGEPROC SampleCoverage =
4098 __glGetProcAddress("glSampleCoverage");
4099 SampleCoverage((GLclampf) bswap_FLOAT32(pc + 0), *(GLboolean *) (pc + 4));
4100}
4101
4102void
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
4112void
4113__glXDispSwap_FogCoorddv(GLbyte * pc)
4114{
4115 PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
4116
4117#ifdef __GLX_ALIGN641
4118 if ((unsigned long) (pc) & 7) {
4119 (void) memmove(pc - 4, pc, 8)__builtin___memmove_chk (pc - 4, pc, 8, __builtin_object_size
(pc - 4, 0))
;
4120 pc -= 4;
4121 }
4122#endif
4123
4124 FogCoorddv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
4125}
4126
4127void
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
4136void
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
4151void
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
4159void
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
4174void
4175__glXDispSwap_SecondaryColor3bv(GLbyte * pc)
4176{
4177 PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
4178 __glGetProcAddress("glSecondaryColor3bv");
4179 SecondaryColor3bv((const GLbyte *) (pc + 0));
4180}
4181
4182void
4183__glXDispSwap_SecondaryColor3dv(GLbyte * pc)
4184{
4185 PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
4186 __glGetProcAddress("glSecondaryColor3dv");
4187#ifdef __GLX_ALIGN641
4188 if ((unsigned long) (pc) & 7) {
4189 (void) memmove(pc - 4, pc, 24)__builtin___memmove_chk (pc - 4, pc, 24, __builtin_object_size
(pc - 4, 0))
;
4190 pc -= 4;
4191 }
4192#endif
4193
4194 SecondaryColor3dv((const GLdouble *)
4195 bswap_64_array((uint64_t *) (pc + 0), 3));
4196}
4197
4198void
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
4206void
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
4215void
4216__glXDispSwap_SecondaryColor3ubv(GLbyte * pc)
4217{
4218 PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
4219 __glGetProcAddress("glSecondaryColor3ubv");
4220 SecondaryColor3ubv((const GLubyte *) (pc + 0));
4221}
4222
4223void
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
4232void
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
4241void
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
4249void
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
4257int
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_SIZE8;
4268 if (cx != NULL((void*)0)) {
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 = Success0;
4275 }
4276
4277 return error;
4278}
4279
4280void
4281__glXDispSwap_EndQuery(GLbyte * pc)
4282{
4283 PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
4284
4285 EndQuery((GLenum) bswap_ENUM(pc + 0));
4286}
4287
4288int
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_SIZE8;
4298 if (cx != NULL((void*)0)) {
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((void*)0))
4306 return BadAlloc11;
4307
4308 GenQueries(n, ids);
4309 (void) bswap_32_array((uint32_t *) ids, n);
4310 __glXSendReplySwap(cl->client, ids, n, 4, GL_TRUE0x1, 0);
4311 error = Success0;
4312 }
4313
4314 return error;
4315}
4316
4317int
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_SIZE8;
4328 if (cx != NULL((void*)0)) {
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((void*)0))
4338 return BadAlloc11;
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_FALSE0x0, 0);
4344 error = Success0;
4345 }
4346
4347 return error;
4348}
4349
4350int
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_SIZE8;
4361 if (cx != NULL((void*)0)) {
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((void*)0))
4371 return BadAlloc11;
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_FALSE0x0, 0);
4377 error = Success0;
4378 }
4379
4380 return error;
4381}
4382
4383int
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_SIZE8;
4393 if (cx != NULL((void*)0)) {
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((void*)0))
4403 return BadAlloc11;
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_FALSE0x0, 0);
4409 error = Success0;
4410 }
4411
4412 return error;
4413}
4414
4415int
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_SIZE8;
4425 if (cx != NULL((void*)0)) {
4426 GLboolean retval;
4427
4428 retval = IsQuery((GLuint) bswap_CARD32(pc + 0));
4429 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
4430 error = Success0;
4431 }
4432
4433 return error;
4434}
4435
4436void
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
4445void
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
4454void
4455__glXDispSwap_VertexAttrib1dv(GLbyte * pc)
4456{
4457 PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
4458 __glGetProcAddress("glVertexAttrib1dv");
4459#ifdef __GLX_ALIGN641
4460 if ((unsigned long) (pc) & 7) {
4461 (void) memmove(pc - 4, pc, 12)__builtin___memmove_chk (pc - 4, pc, 12, __builtin_object_size
(pc - 4, 0))
;
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
4471void
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
4480void
4481__glXDispSwap_VertexAttrib2dv(GLbyte * pc)
4482{
4483 PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
4484 __glGetProcAddress("glVertexAttrib2dv");
4485#ifdef __GLX_ALIGN641
4486 if ((unsigned long) (pc) & 7) {
4487 (void) memmove(pc - 4, pc, 20)__builtin___memmove_chk (pc - 4, pc, 20, __builtin_object_size
(pc - 4, 0))
;
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
4497void
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
4506void
4507__glXDispSwap_VertexAttrib3dv(GLbyte * pc)
4508{
4509 PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
4510 __glGetProcAddress("glVertexAttrib3dv");
4511#ifdef __GLX_ALIGN641
4512 if ((unsigned long) (pc) & 7) {
4513 (void) memmove(pc - 4, pc, 28)__builtin___memmove_chk (pc - 4, pc, 28, __builtin_object_size
(pc - 4, 0))
;
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
4523void
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
4532void
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
4540void
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
4549void
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
4559void
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
4568void
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
4578void
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
4588void
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
4596void
4597__glXDispSwap_VertexAttrib4dv(GLbyte * pc)
4598{
4599 PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
4600 __glGetProcAddress("glVertexAttrib4dv");
4601#ifdef __GLX_ALIGN641
4602 if ((unsigned long) (pc) & 7) {
4603 (void) memmove(pc - 4, pc, 36)__builtin___memmove_chk (pc - 4, pc, 36, __builtin_object_size
(pc - 4, 0))
;
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
4613void
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
4622void
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
4631void
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
4639void
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
4648void
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
4658void
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
4666void
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
4674int
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_SIZE12;
4685 if (cx != NULL((void*)0)) {
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 = Success0;
4692 }
4693
4694 return error;
4695}
4696
4697int
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_SIZE12;
4708 if (cx != NULL((void*)0)) {
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((void*)0))
4716 return BadAlloc11;
4717
4718 GenProgramsARB(n, programs);
4719 (void) bswap_32_array((uint32_t *) programs, n);
4720 __glXSendReplySwap(cl->client, programs, n, 4, GL_TRUE0x1, 0);
4721 error = Success0;
4722 }
4723
4724 return error;
4725}
4726
4727int
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_SIZE12;
4738 if (cx != NULL((void*)0)) {
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_FALSE0x0, 0);
4745 error = Success0;
4746 }
4747
4748 return error;
4749}
4750
4751int
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_SIZE12;
4762 if (cx != NULL((void*)0)) {
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_FALSE0x0, 0);
4769 error = Success0;
4770 }
4771
4772 return error;
4773}
4774
4775int
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_SIZE12;
4786 if (cx != NULL((void*)0)) {
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_FALSE0x0, 0);
4793 error = Success0;
4794 }
4795
4796 return error;
4797}
4798
4799int
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_SIZE12;
4810 if (cx != NULL((void*)0)) {
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_FALSE0x0, 0);
4817 error = Success0;
4818 }
4819
4820 return error;
4821}
4822
4823int
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_SIZE12;
4834 if (cx != NULL((void*)0)) {
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((void*)0))
4844 return BadAlloc11;
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_FALSE0x0, 0);
4850 error = Success0;
4851 }
4852
4853 return error;
4854}
4855
4856int
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_SIZE12;
4866 if (cx != NULL((void*)0)) {
4867 GLboolean retval;
4868
4869 retval = IsProgramARB((GLuint) bswap_CARD32(pc + 0));
4870 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
4871 error = Success0;
4872 }
4873
4874 return error;
4875}
4876
4877void
4878__glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
4879{
4880 PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
4881 __glGetProcAddress("glProgramEnvParameter4dvARB");
4882#ifdef __GLX_ALIGN641
4883 if ((unsigned long) (pc) & 7) {
4884 (void) memmove(pc - 4, pc, 40)__builtin___memmove_chk (pc - 4, pc, 40, __builtin_object_size
(pc - 4, 0))
;
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
4895void
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
4906void
4907__glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
4908{
4909 PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
4910 __glGetProcAddress("glProgramLocalParameter4dvARB");
4911#ifdef __GLX_ALIGN641
4912 if ((unsigned long) (pc) & 7) {
4913 (void) memmove(pc - 4, pc, 40)__builtin___memmove_chk (pc - 4, pc, 40, __builtin_object_size
(pc - 4, 0))
;
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
4924void
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
4935void
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
4947void
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
4957void
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
4967void
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
4977void
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
4987void
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
4995void
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
5004void
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
5019int
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_SIZE12;
5030 if (cx != NULL((void*)0)) {
5031 GLenum retval;
5032
5033 retval = CheckFramebufferStatus((GLenum) bswap_ENUM(pc + 0));
5034 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
5035 error = Success0;
5036 }
5037
5038 return error;
5039}
5040
5041void
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
5053void
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
5065void
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
5076void
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
5088void
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
5100void
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
5113void
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
5125int
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_SIZE12;
5136 if (cx != NULL((void*)0)) {
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((void*)0))
5145 return BadAlloc11;
5146
5147 GenFramebuffers(n, framebuffers);
5148 (void) bswap_32_array((uint32_t *) framebuffers, n);
5149 __glXSendReplySwap(cl->client, framebuffers, n, 4, GL_TRUE0x1, 0);
5150 error = Success0;
5151 }
5152
5153 return error;
5154}
5155
5156int
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_SIZE12;
5167 if (cx != NULL((void*)0)) {
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((void*)0))
5176 return BadAlloc11;
5177
5178 GenRenderbuffers(n, renderbuffers);
5179 (void) bswap_32_array((uint32_t *) renderbuffers, n);
5180 __glXSendReplySwap(cl->client, renderbuffers, n, 4, GL_TRUE0x1, 0);
5181 error = Success0;
5182 }
5183
5184 return error;
5185}
5186
5187void
5188__glXDispSwap_GenerateMipmap(GLbyte * pc)
5189{
5190 PFNGLGENERATEMIPMAPPROC GenerateMipmap =
5191 __glGetProcAddress("glGenerateMipmap");
5192 GenerateMipmap((GLenum) bswap_ENUM(pc + 0));
5193}
5194
5195int
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_SIZE12;
5208 if (cx != NULL((void*)0)) {
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_FALSE0x0, 0);
5217 error = Success0;
5218 }
5219
5220 return error;
5221}
5222
5223int
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_SIZE12;
5234 if (cx != NULL((void*)0)) {
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_FALSE0x0, 0);
5241 error = Success0;
5242 }
5243
5244 return error;
5245}
5246
5247int
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_SIZE12;
5258 if (cx != NULL((void*)0)) {
5259 GLboolean retval;
5260
5261 retval = IsFramebuffer((GLuint) bswap_CARD32(pc + 0));
5262 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
5263 error = Success0;
5264 }
5265
5266 return error;
5267}
5268
5269int
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_SIZE12;
5280 if (cx != NULL((void*)0)) {
5281 GLboolean retval;
5282
5283 retval = IsRenderbuffer((GLuint) bswap_CARD32(pc + 0));
5284 __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE0x0, retval);
5285 error = Success0;
5286 }
5287
5288 return error;
5289}
5290
5291void
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
5302void
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
5314void
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
5323void
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
5331void
5332__glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
5333{
5334 PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
5335 __glGetProcAddress("glVertexAttrib1dvNV");
5336#ifdef __GLX_ALIGN641
5337 if ((unsigned long) (pc) & 7) {
5338 (void) memmove(pc - 4, pc, 12)__builtin___memmove_chk (pc - 4, pc, 12, __builtin_object_size
(pc - 4, 0))
;
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
5348void
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
5358void
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
5368void
5369__glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
5370{
5371 PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
5372 __glGetProcAddress("glVertexAttrib2dvNV");
5373#ifdef __GLX_ALIGN641
5374 if ((unsigned long) (pc) & 7) {
5375 (void) memmove(pc - 4, pc, 20)__builtin___memmove_chk (pc - 4, pc, 20, __builtin_object_size
(pc - 4, 0))
;
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
5385void
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
5395void
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
5405void
5406__glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
5407{
5408 PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
5409 __glGetProcAddress("glVertexAttrib3dvNV");
5410#ifdef __GLX_ALIGN641
5411 if ((unsigned long) (pc) & 7) {
5412 (void) memmove(pc - 4, pc, 28)__builtin___memmove_chk (pc - 4, pc, 28, __builtin_object_size
(pc - 4, 0))
;
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
5422void
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
5432void
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
5442void
5443__glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
5444{
5445 PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
5446 __glGetProcAddress("glVertexAttrib4dvNV");
5447#ifdef __GLX_ALIGN641
5448 if ((unsigned long) (pc) & 7) {
5449 (void) memmove(pc - 4, pc, 36)__builtin___memmove_chk (pc - 4, pc, 36, __builtin_object_size
(pc - 4, 0))
;
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
5459void
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
5469void
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
5479void
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
5488void
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_ALIGN641
5496 const GLuint cmdlen = 12 + __GLX_PAD((n * 8))((((n * 8)) + 3) & ~3) - 4;
5497
5498 if ((unsigned long) (pc) & 7) {
5499 (void) memmove(pc - 4, pc, cmdlen)__builtin___memmove_chk (pc - 4, pc, cmdlen, __builtin_object_size
(pc - 4, 0))
;
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
5510void
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
5523void
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
5536void
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_ALIGN641
5544 const GLuint cmdlen = 12 + __GLX_PAD((n * 16))((((n * 16)) + 3) & ~3) - 4;
5545
5546 if ((unsigned long) (pc) & 7) {
5547 (void) memmove(pc - 4, pc, cmdlen)__builtin___memmove_chk (pc - 4, pc, cmdlen, __builtin_object_size
(pc - 4, 0))
;
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
5558void
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
5571void
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
5584void
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_ALIGN641
5592 const GLuint cmdlen = 12 + __GLX_PAD((n * 24))((((n * 24)) + 3) & ~3) - 4;
5593
5594 if ((unsigned long) (pc) & 7) {
5595 (void) memmove(pc - 4, pc, cmdlen)__builtin___memmove_chk (pc - 4, pc, cmdlen, __builtin_object_size
(pc - 4, 0))
;
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
5606void
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
5619void
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
5632void
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_ALIGN641
5640 const GLuint cmdlen = 12 + __GLX_PAD((n * 32))((((n * 32)) + 3) & ~3) - 4;
5641
5642 if ((unsigned long) (pc) & 7) {
5643 (void) memmove(pc - 4, pc, cmdlen)__builtin___memmove_chk (pc - 4, pc, cmdlen, __builtin_object_size
(pc - 4, 0))
;
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
5654void
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
5667void
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
5680void
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
5691void
5692__glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
5693{
5694 PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
5695 __glGetProcAddress("glActiveStencilFaceEXT");
5696 ActiveStencilFaceEXT((GLenum) bswap_ENUM(pc + 0));
5697}