File: | glx/indirect_dispatch_swap.c |
Location: | line 1801, column 5 |
Description: | Value stored to 'pc' is never read |
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 | |
39 | typedef 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 | |
43 | extern GLboolean __glXErrorOccured(void); |
44 | extern void __glXClearErrorOccured(void); |
45 | |
46 | static const unsigned dummy_answer[2] = { 0, 0 }; |
47 | |
48 | static GLsizei |
49 | bswap_CARD32(const void *src) |
50 | { |
51 | union { |
52 | uint32_t dst; |
53 | GLsizei ret; |
54 | } x; |
55 | |
56 | x.dst = bswap_32(*(uint32_t *) src)(__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 | |
60 | static GLshort |
61 | bswap_CARD16(const void *src) |
62 | { |
63 | union { |
64 | uint16_t dst; |
65 | GLshort ret; |
66 | } x; |
67 | |
68 | x.dst = bswap_16(*(uint16_t *) src)((__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 | |
72 | static GLenum |
73 | bswap_ENUM(const void *src) |
74 | { |
75 | union { |
76 | uint32_t dst; |
77 | GLenum ret; |
78 | } x; |
79 | |
80 | x.dst = bswap_32(*(uint32_t *) src)(__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 | |
84 | static GLsync |
85 | bswap_CARD64(const void *src) |
86 | { |
87 | union { |
88 | uint64_t dst; |
89 | GLsync ret; |
90 | } x; |
91 | |
92 | x.dst = bswap_64(*(uint64_t *) src)(__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 | |
96 | static GLdouble |
97 | bswap_FLOAT64(const void *src) |
98 | { |
99 | union { |
100 | uint64_t dst; |
101 | GLdouble ret; |
102 | } x; |
103 | |
104 | x.dst = bswap_64(*(uint64_t *) src)(__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 | |
108 | static GLfloat |
109 | bswap_FLOAT32(const void *src) |
110 | { |
111 | union { |
112 | uint32_t dst; |
113 | GLfloat ret; |
114 | } x; |
115 | |
116 | x.dst = bswap_32(*(uint32_t *) src)(__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 | |
120 | static void * |
121 | bswap_16_array(uint16_t * src, unsigned count) |
122 | { |
123 | unsigned i; |
124 | |
125 | for (i = 0; i < count; i++) { |
126 | uint16_t temp = bswap_16(src[i])((__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 | |
134 | static void * |
135 | bswap_32_array(uint32_t * src, unsigned count) |
136 | { |
137 | unsigned i; |
138 | |
139 | for (i = 0; i < count; i++) { |
140 | uint32_t temp = bswap_32(src[i])(__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 | |
148 | static void * |
149 | bswap_64_array(uint64_t * src, unsigned count) |
150 | { |
151 | unsigned i; |
152 | |
153 | for (i = 0; i < count; i++) { |
154 | uint64_t temp = bswap_64(src[i])(__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 | |
162 | int |
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 | |
179 | int |
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 | |
196 | void |
197 | __glXDispSwap_CallList(GLbyte * pc) |
198 | { |
199 | glCallList((GLuint) bswap_CARD32(pc + 0)); |
200 | } |
201 | |
202 | void |
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 | |
233 | int |
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 | |
251 | int |
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 | |
271 | void |
272 | __glXDispSwap_ListBase(GLbyte * pc) |
273 | { |
274 | glListBase((GLuint) bswap_CARD32(pc + 0)); |
275 | } |
276 | |
277 | void |
278 | __glXDispSwap_Begin(GLbyte * pc) |
279 | { |
280 | glBegin((GLenum) bswap_ENUM(pc + 0)); |
281 | } |
282 | |
283 | void |
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 | |
304 | void |
305 | __glXDispSwap_Color3bv(GLbyte * pc) |
306 | { |
307 | glColor3bv((const GLbyte *) (pc + 0)); |
308 | } |
309 | |
310 | void |
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 | |
323 | void |
324 | __glXDispSwap_Color3fv(GLbyte * pc) |
325 | { |
326 | glColor3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
327 | } |
328 | |
329 | void |
330 | __glXDispSwap_Color3iv(GLbyte * pc) |
331 | { |
332 | glColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
333 | } |
334 | |
335 | void |
336 | __glXDispSwap_Color3sv(GLbyte * pc) |
337 | { |
338 | glColor3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3)); |
339 | } |
340 | |
341 | void |
342 | __glXDispSwap_Color3ubv(GLbyte * pc) |
343 | { |
344 | glColor3ubv((const GLubyte *) (pc + 0)); |
345 | } |
346 | |
347 | void |
348 | __glXDispSwap_Color3uiv(GLbyte * pc) |
349 | { |
350 | glColor3uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
351 | } |
352 | |
353 | void |
354 | __glXDispSwap_Color3usv(GLbyte * pc) |
355 | { |
356 | glColor3usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 3)); |
357 | } |
358 | |
359 | void |
360 | __glXDispSwap_Color4bv(GLbyte * pc) |
361 | { |
362 | glColor4bv((const GLbyte *) (pc + 0)); |
363 | } |
364 | |
365 | void |
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 | |
378 | void |
379 | __glXDispSwap_Color4fv(GLbyte * pc) |
380 | { |
381 | glColor4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
382 | } |
383 | |
384 | void |
385 | __glXDispSwap_Color4iv(GLbyte * pc) |
386 | { |
387 | glColor4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
388 | } |
389 | |
390 | void |
391 | __glXDispSwap_Color4sv(GLbyte * pc) |
392 | { |
393 | glColor4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4)); |
394 | } |
395 | |
396 | void |
397 | __glXDispSwap_Color4ubv(GLbyte * pc) |
398 | { |
399 | glColor4ubv((const GLubyte *) (pc + 0)); |
400 | } |
401 | |
402 | void |
403 | __glXDispSwap_Color4uiv(GLbyte * pc) |
404 | { |
405 | glColor4uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
406 | } |
407 | |
408 | void |
409 | __glXDispSwap_Color4usv(GLbyte * pc) |
410 | { |
411 | glColor4usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 4)); |
412 | } |
413 | |
414 | void |
415 | __glXDispSwap_EdgeFlagv(GLbyte * pc) |
416 | { |
417 | glEdgeFlagv((const GLboolean *) (pc + 0)); |
418 | } |
419 | |
420 | void |
421 | __glXDispSwap_End(GLbyte * pc) |
422 | { |
423 | glEnd(); |
424 | } |
425 | |
426 | void |
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 | |
439 | void |
440 | __glXDispSwap_Indexfv(GLbyte * pc) |
441 | { |
442 | glIndexfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1)); |
443 | } |
444 | |
445 | void |
446 | __glXDispSwap_Indexiv(GLbyte * pc) |
447 | { |
448 | glIndexiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1)); |
449 | } |
450 | |
451 | void |
452 | __glXDispSwap_Indexsv(GLbyte * pc) |
453 | { |
454 | glIndexsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1)); |
455 | } |
456 | |
457 | void |
458 | __glXDispSwap_Normal3bv(GLbyte * pc) |
459 | { |
460 | glNormal3bv((const GLbyte *) (pc + 0)); |
461 | } |
462 | |
463 | void |
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 | |
476 | void |
477 | __glXDispSwap_Normal3fv(GLbyte * pc) |
478 | { |
479 | glNormal3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
480 | } |
481 | |
482 | void |
483 | __glXDispSwap_Normal3iv(GLbyte * pc) |
484 | { |
485 | glNormal3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
486 | } |
487 | |
488 | void |
489 | __glXDispSwap_Normal3sv(GLbyte * pc) |
490 | { |
491 | glNormal3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3)); |
492 | } |
493 | |
494 | void |
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 | |
507 | void |
508 | __glXDispSwap_RasterPos2fv(GLbyte * pc) |
509 | { |
510 | glRasterPos2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
511 | } |
512 | |
513 | void |
514 | __glXDispSwap_RasterPos2iv(GLbyte * pc) |
515 | { |
516 | glRasterPos2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
517 | } |
518 | |
519 | void |
520 | __glXDispSwap_RasterPos2sv(GLbyte * pc) |
521 | { |
522 | glRasterPos2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2)); |
523 | } |
524 | |
525 | void |
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 | |
538 | void |
539 | __glXDispSwap_RasterPos3fv(GLbyte * pc) |
540 | { |
541 | glRasterPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
542 | } |
543 | |
544 | void |
545 | __glXDispSwap_RasterPos3iv(GLbyte * pc) |
546 | { |
547 | glRasterPos3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
548 | } |
549 | |
550 | void |
551 | __glXDispSwap_RasterPos3sv(GLbyte * pc) |
552 | { |
553 | glRasterPos3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3)); |
554 | } |
555 | |
556 | void |
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 | |
569 | void |
570 | __glXDispSwap_RasterPos4fv(GLbyte * pc) |
571 | { |
572 | glRasterPos4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
573 | } |
574 | |
575 | void |
576 | __glXDispSwap_RasterPos4iv(GLbyte * pc) |
577 | { |
578 | glRasterPos4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
579 | } |
580 | |
581 | void |
582 | __glXDispSwap_RasterPos4sv(GLbyte * pc) |
583 | { |
584 | glRasterPos4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4)); |
585 | } |
586 | |
587 | void |
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 | |
601 | void |
602 | __glXDispSwap_Rectfv(GLbyte * pc) |
603 | { |
604 | glRectfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2), |
605 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), 2)); |
606 | } |
607 | |
608 | void |
609 | __glXDispSwap_Rectiv(GLbyte * pc) |
610 | { |
611 | glRectiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2), |
612 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), 2)); |
613 | } |
614 | |
615 | void |
616 | __glXDispSwap_Rectsv(GLbyte * pc) |
617 | { |
618 | glRectsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2), |
619 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2)); |
620 | } |
621 | |
622 | void |
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 | |
635 | void |
636 | __glXDispSwap_TexCoord1fv(GLbyte * pc) |
637 | { |
638 | glTexCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1)); |
639 | } |
640 | |
641 | void |
642 | __glXDispSwap_TexCoord1iv(GLbyte * pc) |
643 | { |
644 | glTexCoord1iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1)); |
645 | } |
646 | |
647 | void |
648 | __glXDispSwap_TexCoord1sv(GLbyte * pc) |
649 | { |
650 | glTexCoord1sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1)); |
651 | } |
652 | |
653 | void |
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 | |
666 | void |
667 | __glXDispSwap_TexCoord2fv(GLbyte * pc) |
668 | { |
669 | glTexCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
670 | } |
671 | |
672 | void |
673 | __glXDispSwap_TexCoord2iv(GLbyte * pc) |
674 | { |
675 | glTexCoord2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
676 | } |
677 | |
678 | void |
679 | __glXDispSwap_TexCoord2sv(GLbyte * pc) |
680 | { |
681 | glTexCoord2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2)); |
682 | } |
683 | |
684 | void |
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 | |
697 | void |
698 | __glXDispSwap_TexCoord3fv(GLbyte * pc) |
699 | { |
700 | glTexCoord3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
701 | } |
702 | |
703 | void |
704 | __glXDispSwap_TexCoord3iv(GLbyte * pc) |
705 | { |
706 | glTexCoord3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
707 | } |
708 | |
709 | void |
710 | __glXDispSwap_TexCoord3sv(GLbyte * pc) |
711 | { |
712 | glTexCoord3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3)); |
713 | } |
714 | |
715 | void |
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 | |
728 | void |
729 | __glXDispSwap_TexCoord4fv(GLbyte * pc) |
730 | { |
731 | glTexCoord4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
732 | } |
733 | |
734 | void |
735 | __glXDispSwap_TexCoord4iv(GLbyte * pc) |
736 | { |
737 | glTexCoord4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
738 | } |
739 | |
740 | void |
741 | __glXDispSwap_TexCoord4sv(GLbyte * pc) |
742 | { |
743 | glTexCoord4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4)); |
744 | } |
745 | |
746 | void |
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 | |
759 | void |
760 | __glXDispSwap_Vertex2fv(GLbyte * pc) |
761 | { |
762 | glVertex2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
763 | } |
764 | |
765 | void |
766 | __glXDispSwap_Vertex2iv(GLbyte * pc) |
767 | { |
768 | glVertex2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
769 | } |
770 | |
771 | void |
772 | __glXDispSwap_Vertex2sv(GLbyte * pc) |
773 | { |
774 | glVertex2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2)); |
775 | } |
776 | |
777 | void |
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 | |
790 | void |
791 | __glXDispSwap_Vertex3fv(GLbyte * pc) |
792 | { |
793 | glVertex3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
794 | } |
795 | |
796 | void |
797 | __glXDispSwap_Vertex3iv(GLbyte * pc) |
798 | { |
799 | glVertex3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
800 | } |
801 | |
802 | void |
803 | __glXDispSwap_Vertex3sv(GLbyte * pc) |
804 | { |
805 | glVertex3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3)); |
806 | } |
807 | |
808 | void |
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 | |
821 | void |
822 | __glXDispSwap_Vertex4fv(GLbyte * pc) |
823 | { |
824 | glVertex4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
825 | } |
826 | |
827 | void |
828 | __glXDispSwap_Vertex4iv(GLbyte * pc) |
829 | { |
830 | glVertex4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4)); |
831 | } |
832 | |
833 | void |
834 | __glXDispSwap_Vertex4sv(GLbyte * pc) |
835 | { |
836 | glVertex4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4)); |
837 | } |
838 | |
839 | void |
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 | |
853 | void |
854 | __glXDispSwap_ColorMaterial(GLbyte * pc) |
855 | { |
856 | glColorMaterial((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4)); |
857 | } |
858 | |
859 | void |
860 | __glXDispSwap_CullFace(GLbyte * pc) |
861 | { |
862 | glCullFace((GLenum) bswap_ENUM(pc + 0)); |
863 | } |
864 | |
865 | void |
866 | __glXDispSwap_Fogf(GLbyte * pc) |
867 | { |
868 | glFogf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4)); |
869 | } |
870 | |
871 | void |
872 | __glXDispSwap_Fogfv(GLbyte * pc) |
873 | { |
874 | const GLenum pname = (GLenum) bswap_ENUM(pc + 0); |
875 | const GLfloat *params; |
876 | |
877 | params = |
878 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
879 | __glFogfv_size(pname)); |
880 | |
881 | glFogfv(pname, params); |
882 | } |
883 | |
884 | void |
885 | __glXDispSwap_Fogi(GLbyte * pc) |
886 | { |
887 | glFogi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4)); |
888 | } |
889 | |
890 | void |
891 | __glXDispSwap_Fogiv(GLbyte * pc) |
892 | { |
893 | const GLenum pname = (GLenum) bswap_ENUM(pc + 0); |
894 | const GLint *params; |
895 | |
896 | params = |
897 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
898 | __glFogiv_size(pname)); |
899 | |
900 | glFogiv(pname, params); |
901 | } |
902 | |
903 | void |
904 | __glXDispSwap_FrontFace(GLbyte * pc) |
905 | { |
906 | glFrontFace((GLenum) bswap_ENUM(pc + 0)); |
907 | } |
908 | |
909 | void |
910 | __glXDispSwap_Hint(GLbyte * pc) |
911 | { |
912 | glHint((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4)); |
913 | } |
914 | |
915 | void |
916 | __glXDispSwap_Lightf(GLbyte * pc) |
917 | { |
918 | glLightf((GLenum) bswap_ENUM(pc + 0), |
919 | (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8)); |
920 | } |
921 | |
922 | void |
923 | __glXDispSwap_Lightfv(GLbyte * pc) |
924 | { |
925 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
926 | const GLfloat *params; |
927 | |
928 | params = |
929 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
930 | __glLightfv_size(pname)); |
931 | |
932 | glLightfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
933 | } |
934 | |
935 | void |
936 | __glXDispSwap_Lighti(GLbyte * pc) |
937 | { |
938 | glLighti((GLenum) bswap_ENUM(pc + 0), |
939 | (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8)); |
940 | } |
941 | |
942 | void |
943 | __glXDispSwap_Lightiv(GLbyte * pc) |
944 | { |
945 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
946 | const GLint *params; |
947 | |
948 | params = |
949 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
950 | __glLightiv_size(pname)); |
951 | |
952 | glLightiv((GLenum) bswap_ENUM(pc + 0), pname, params); |
953 | } |
954 | |
955 | void |
956 | __glXDispSwap_LightModelf(GLbyte * pc) |
957 | { |
958 | glLightModelf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4)); |
959 | } |
960 | |
961 | void |
962 | __glXDispSwap_LightModelfv(GLbyte * pc) |
963 | { |
964 | const GLenum pname = (GLenum) bswap_ENUM(pc + 0); |
965 | const GLfloat *params; |
966 | |
967 | params = |
968 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
969 | __glLightModelfv_size(pname)); |
970 | |
971 | glLightModelfv(pname, params); |
972 | } |
973 | |
974 | void |
975 | __glXDispSwap_LightModeli(GLbyte * pc) |
976 | { |
977 | glLightModeli((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4)); |
978 | } |
979 | |
980 | void |
981 | __glXDispSwap_LightModeliv(GLbyte * pc) |
982 | { |
983 | const GLenum pname = (GLenum) bswap_ENUM(pc + 0); |
984 | const GLint *params; |
985 | |
986 | params = |
987 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
988 | __glLightModeliv_size(pname)); |
989 | |
990 | glLightModeliv(pname, params); |
991 | } |
992 | |
993 | void |
994 | __glXDispSwap_LineStipple(GLbyte * pc) |
995 | { |
996 | glLineStipple((GLint) bswap_CARD32(pc + 0), |
997 | (GLushort) bswap_CARD16(pc + 4)); |
998 | } |
999 | |
1000 | void |
1001 | __glXDispSwap_LineWidth(GLbyte * pc) |
1002 | { |
1003 | glLineWidth((GLfloat) bswap_FLOAT32(pc + 0)); |
1004 | } |
1005 | |
1006 | void |
1007 | __glXDispSwap_Materialf(GLbyte * pc) |
1008 | { |
1009 | glMaterialf((GLenum) bswap_ENUM(pc + 0), |
1010 | (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8)); |
1011 | } |
1012 | |
1013 | void |
1014 | __glXDispSwap_Materialfv(GLbyte * pc) |
1015 | { |
1016 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1017 | const GLfloat *params; |
1018 | |
1019 | params = |
1020 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
1021 | __glMaterialfv_size(pname)); |
1022 | |
1023 | glMaterialfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1024 | } |
1025 | |
1026 | void |
1027 | __glXDispSwap_Materiali(GLbyte * pc) |
1028 | { |
1029 | glMateriali((GLenum) bswap_ENUM(pc + 0), |
1030 | (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8)); |
1031 | } |
1032 | |
1033 | void |
1034 | __glXDispSwap_Materialiv(GLbyte * pc) |
1035 | { |
1036 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1037 | const GLint *params; |
1038 | |
1039 | params = |
1040 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
1041 | __glMaterialiv_size(pname)); |
1042 | |
1043 | glMaterialiv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1044 | } |
1045 | |
1046 | void |
1047 | __glXDispSwap_PointSize(GLbyte * pc) |
1048 | { |
1049 | glPointSize((GLfloat) bswap_FLOAT32(pc + 0)); |
1050 | } |
1051 | |
1052 | void |
1053 | __glXDispSwap_PolygonMode(GLbyte * pc) |
1054 | { |
1055 | glPolygonMode((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4)); |
1056 | } |
1057 | |
1058 | void |
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 | |
1074 | void |
1075 | __glXDispSwap_Scissor(GLbyte * pc) |
1076 | { |
1077 | glScissor((GLint) bswap_CARD32(pc + 0), |
1078 | (GLint) bswap_CARD32(pc + 4), |
1079 | (GLsizei) bswap_CARD32(pc + 8), (GLsizei) bswap_CARD32(pc + 12)); |
1080 | } |
1081 | |
1082 | void |
1083 | __glXDispSwap_ShadeModel(GLbyte * pc) |
1084 | { |
1085 | glShadeModel((GLenum) bswap_ENUM(pc + 0)); |
1086 | } |
1087 | |
1088 | void |
1089 | __glXDispSwap_TexParameterf(GLbyte * pc) |
1090 | { |
1091 | glTexParameterf((GLenum) bswap_ENUM(pc + 0), |
1092 | (GLenum) bswap_ENUM(pc + 4), |
1093 | (GLfloat) bswap_FLOAT32(pc + 8)); |
1094 | } |
1095 | |
1096 | void |
1097 | __glXDispSwap_TexParameterfv(GLbyte * pc) |
1098 | { |
1099 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1100 | const GLfloat *params; |
1101 | |
1102 | params = |
1103 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
1104 | __glTexParameterfv_size(pname)); |
1105 | |
1106 | glTexParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1107 | } |
1108 | |
1109 | void |
1110 | __glXDispSwap_TexParameteri(GLbyte * pc) |
1111 | { |
1112 | glTexParameteri((GLenum) bswap_ENUM(pc + 0), |
1113 | (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8)); |
1114 | } |
1115 | |
1116 | void |
1117 | __glXDispSwap_TexParameteriv(GLbyte * pc) |
1118 | { |
1119 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1120 | const GLint *params; |
1121 | |
1122 | params = |
1123 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
1124 | __glTexParameteriv_size(pname)); |
1125 | |
1126 | glTexParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1127 | } |
1128 | |
1129 | void |
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 | |
1152 | void |
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 | |
1176 | void |
1177 | __glXDispSwap_TexEnvf(GLbyte * pc) |
1178 | { |
1179 | glTexEnvf((GLenum) bswap_ENUM(pc + 0), |
1180 | (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8)); |
1181 | } |
1182 | |
1183 | void |
1184 | __glXDispSwap_TexEnvfv(GLbyte * pc) |
1185 | { |
1186 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1187 | const GLfloat *params; |
1188 | |
1189 | params = |
1190 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
1191 | __glTexEnvfv_size(pname)); |
1192 | |
1193 | glTexEnvfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1194 | } |
1195 | |
1196 | void |
1197 | __glXDispSwap_TexEnvi(GLbyte * pc) |
1198 | { |
1199 | glTexEnvi((GLenum) bswap_ENUM(pc + 0), |
1200 | (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8)); |
1201 | } |
1202 | |
1203 | void |
1204 | __glXDispSwap_TexEnviv(GLbyte * pc) |
1205 | { |
1206 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1207 | const GLint *params; |
1208 | |
1209 | params = |
1210 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
1211 | __glTexEnviv_size(pname)); |
1212 | |
1213 | glTexEnviv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1214 | } |
1215 | |
1216 | void |
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 | |
1230 | void |
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 | |
1253 | void |
1254 | __glXDispSwap_TexGenf(GLbyte * pc) |
1255 | { |
1256 | glTexGenf((GLenum) bswap_ENUM(pc + 0), |
1257 | (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8)); |
1258 | } |
1259 | |
1260 | void |
1261 | __glXDispSwap_TexGenfv(GLbyte * pc) |
1262 | { |
1263 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1264 | const GLfloat *params; |
1265 | |
1266 | params = |
1267 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
1268 | __glTexGenfv_size(pname)); |
1269 | |
1270 | glTexGenfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1271 | } |
1272 | |
1273 | void |
1274 | __glXDispSwap_TexGeni(GLbyte * pc) |
1275 | { |
1276 | glTexGeni((GLenum) bswap_ENUM(pc + 0), |
1277 | (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8)); |
1278 | } |
1279 | |
1280 | void |
1281 | __glXDispSwap_TexGeniv(GLbyte * pc) |
1282 | { |
1283 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
1284 | const GLint *params; |
1285 | |
1286 | params = |
1287 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
1288 | __glTexGeniv_size(pname)); |
1289 | |
1290 | glTexGeniv((GLenum) bswap_ENUM(pc + 0), pname, params); |
1291 | } |
1292 | |
1293 | void |
1294 | __glXDispSwap_InitNames(GLbyte * pc) |
1295 | { |
1296 | glInitNames(); |
1297 | } |
1298 | |
1299 | void |
1300 | __glXDispSwap_LoadName(GLbyte * pc) |
1301 | { |
1302 | glLoadName((GLuint) bswap_CARD32(pc + 0)); |
1303 | } |
1304 | |
1305 | void |
1306 | __glXDispSwap_PassThrough(GLbyte * pc) |
1307 | { |
1308 | glPassThrough((GLfloat) bswap_FLOAT32(pc + 0)); |
1309 | } |
1310 | |
1311 | void |
1312 | __glXDispSwap_PopName(GLbyte * pc) |
1313 | { |
1314 | glPopName(); |
1315 | } |
1316 | |
1317 | void |
1318 | __glXDispSwap_PushName(GLbyte * pc) |
1319 | { |
1320 | glPushName((GLuint) bswap_CARD32(pc + 0)); |
1321 | } |
1322 | |
1323 | void |
1324 | __glXDispSwap_DrawBuffer(GLbyte * pc) |
1325 | { |
1326 | glDrawBuffer((GLenum) bswap_ENUM(pc + 0)); |
1327 | } |
1328 | |
1329 | void |
1330 | __glXDispSwap_Clear(GLbyte * pc) |
1331 | { |
1332 | glClear((GLbitfield) bswap_CARD32(pc + 0)); |
1333 | } |
1334 | |
1335 | void |
1336 | __glXDispSwap_ClearAccum(GLbyte * pc) |
1337 | { |
1338 | glClearAccum((GLfloat) bswap_FLOAT32(pc + 0), |
1339 | (GLfloat) bswap_FLOAT32(pc + 4), |
1340 | (GLfloat) bswap_FLOAT32(pc + 8), |
1341 | (GLfloat) bswap_FLOAT32(pc + 12)); |
1342 | } |
1343 | |
1344 | void |
1345 | __glXDispSwap_ClearIndex(GLbyte * pc) |
1346 | { |
1347 | glClearIndex((GLfloat) bswap_FLOAT32(pc + 0)); |
1348 | } |
1349 | |
1350 | void |
1351 | __glXDispSwap_ClearColor(GLbyte * pc) |
1352 | { |
1353 | glClearColor((GLclampf) bswap_FLOAT32(pc + 0), |
1354 | (GLclampf) bswap_FLOAT32(pc + 4), |
1355 | (GLclampf) bswap_FLOAT32(pc + 8), |
1356 | (GLclampf) bswap_FLOAT32(pc + 12)); |
1357 | } |
1358 | |
1359 | void |
1360 | __glXDispSwap_ClearStencil(GLbyte * pc) |
1361 | { |
1362 | glClearStencil((GLint) bswap_CARD32(pc + 0)); |
1363 | } |
1364 | |
1365 | void |
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 | |
1378 | void |
1379 | __glXDispSwap_StencilMask(GLbyte * pc) |
1380 | { |
1381 | glStencilMask((GLuint) bswap_CARD32(pc + 0)); |
1382 | } |
1383 | |
1384 | void |
1385 | __glXDispSwap_ColorMask(GLbyte * pc) |
1386 | { |
1387 | glColorMask(*(GLboolean *) (pc + 0), |
1388 | *(GLboolean *) (pc + 1), |
1389 | *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3)); |
1390 | } |
1391 | |
1392 | void |
1393 | __glXDispSwap_DepthMask(GLbyte * pc) |
1394 | { |
1395 | glDepthMask(*(GLboolean *) (pc + 0)); |
1396 | } |
1397 | |
1398 | void |
1399 | __glXDispSwap_IndexMask(GLbyte * pc) |
1400 | { |
1401 | glIndexMask((GLuint) bswap_CARD32(pc + 0)); |
1402 | } |
1403 | |
1404 | void |
1405 | __glXDispSwap_Accum(GLbyte * pc) |
1406 | { |
1407 | glAccum((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4)); |
1408 | } |
1409 | |
1410 | void |
1411 | __glXDispSwap_Disable(GLbyte * pc) |
1412 | { |
1413 | glDisable((GLenum) bswap_ENUM(pc + 0)); |
1414 | } |
1415 | |
1416 | void |
1417 | __glXDispSwap_Enable(GLbyte * pc) |
1418 | { |
1419 | glEnable((GLenum) bswap_ENUM(pc + 0)); |
1420 | } |
1421 | |
1422 | void |
1423 | __glXDispSwap_PopAttrib(GLbyte * pc) |
1424 | { |
1425 | glPopAttrib(); |
1426 | } |
1427 | |
1428 | void |
1429 | __glXDispSwap_PushAttrib(GLbyte * pc) |
1430 | { |
1431 | glPushAttrib((GLbitfield) bswap_CARD32(pc + 0)); |
1432 | } |
1433 | |
1434 | void |
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 | |
1449 | void |
1450 | __glXDispSwap_MapGrid1f(GLbyte * pc) |
1451 | { |
1452 | glMapGrid1f((GLint) bswap_CARD32(pc + 0), |
1453 | (GLfloat) bswap_FLOAT32(pc + 4), |
1454 | (GLfloat) bswap_FLOAT32(pc + 8)); |
1455 | } |
1456 | |
1457 | void |
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 | |
1475 | void |
1476 | __glXDispSwap_MapGrid2f(GLbyte * pc) |
1477 | { |
1478 | glMapGrid2f((GLint) bswap_CARD32(pc + 0), |
1479 | (GLfloat) bswap_FLOAT32(pc + 4), |
1480 | (GLfloat) bswap_FLOAT32(pc + 8), |
1481 | (GLint) bswap_CARD32(pc + 12), |
1482 | (GLfloat) bswap_FLOAT32(pc + 16), |
1483 | (GLfloat) bswap_FLOAT32(pc + 20)); |
1484 | } |
1485 | |
1486 | void |
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 | |
1499 | void |
1500 | __glXDispSwap_EvalCoord1fv(GLbyte * pc) |
1501 | { |
1502 | glEvalCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1)); |
1503 | } |
1504 | |
1505 | void |
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 | |
1518 | void |
1519 | __glXDispSwap_EvalCoord2fv(GLbyte * pc) |
1520 | { |
1521 | glEvalCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2)); |
1522 | } |
1523 | |
1524 | void |
1525 | __glXDispSwap_EvalMesh1(GLbyte * pc) |
1526 | { |
1527 | glEvalMesh1((GLenum) bswap_ENUM(pc + 0), |
1528 | (GLint) bswap_CARD32(pc + 4), (GLint) bswap_CARD32(pc + 8)); |
1529 | } |
1530 | |
1531 | void |
1532 | __glXDispSwap_EvalPoint1(GLbyte * pc) |
1533 | { |
1534 | glEvalPoint1((GLint) bswap_CARD32(pc + 0)); |
1535 | } |
1536 | |
1537 | void |
1538 | __glXDispSwap_EvalMesh2(GLbyte * pc) |
1539 | { |
1540 | glEvalMesh2((GLenum) bswap_ENUM(pc + 0), |
1541 | (GLint) bswap_CARD32(pc + 4), |
1542 | (GLint) bswap_CARD32(pc + 8), |
1543 | (GLint) bswap_CARD32(pc + 12), (GLint) bswap_CARD32(pc + 16)); |
1544 | } |
1545 | |
1546 | void |
1547 | __glXDispSwap_EvalPoint2(GLbyte * pc) |
1548 | { |
1549 | glEvalPoint2((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4)); |
1550 | } |
1551 | |
1552 | void |
1553 | __glXDispSwap_AlphaFunc(GLbyte * pc) |
1554 | { |
1555 | glAlphaFunc((GLenum) bswap_ENUM(pc + 0), (GLclampf) bswap_FLOAT32(pc + 4)); |
1556 | } |
1557 | |
1558 | void |
1559 | __glXDispSwap_BlendFunc(GLbyte * pc) |
1560 | { |
1561 | glBlendFunc((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4)); |
1562 | } |
1563 | |
1564 | void |
1565 | __glXDispSwap_LogicOp(GLbyte * pc) |
1566 | { |
1567 | glLogicOp((GLenum) bswap_ENUM(pc + 0)); |
1568 | } |
1569 | |
1570 | void |
1571 | __glXDispSwap_StencilFunc(GLbyte * pc) |
1572 | { |
1573 | glStencilFunc((GLenum) bswap_ENUM(pc + 0), |
1574 | (GLint) bswap_CARD32(pc + 4), (GLuint) bswap_CARD32(pc + 8)); |
1575 | } |
1576 | |
1577 | void |
1578 | __glXDispSwap_StencilOp(GLbyte * pc) |
1579 | { |
1580 | glStencilOp((GLenum) bswap_ENUM(pc + 0), |
1581 | (GLenum) bswap_ENUM(pc + 4), (GLenum) bswap_ENUM(pc + 8)); |
1582 | } |
1583 | |
1584 | void |
1585 | __glXDispSwap_DepthFunc(GLbyte * pc) |
1586 | { |
1587 | glDepthFunc((GLenum) bswap_ENUM(pc + 0)); |
1588 | } |
1589 | |
1590 | void |
1591 | __glXDispSwap_PixelZoom(GLbyte * pc) |
1592 | { |
1593 | glPixelZoom((GLfloat) bswap_FLOAT32(pc + 0), |
1594 | (GLfloat) bswap_FLOAT32(pc + 4)); |
1595 | } |
1596 | |
1597 | void |
1598 | __glXDispSwap_PixelTransferf(GLbyte * pc) |
1599 | { |
1600 | glPixelTransferf((GLenum) bswap_ENUM(pc + 0), |
1601 | (GLfloat) bswap_FLOAT32(pc + 4)); |
1602 | } |
1603 | |
1604 | void |
1605 | __glXDispSwap_PixelTransferi(GLbyte * pc) |
1606 | { |
1607 | glPixelTransferi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4)); |
1608 | } |
1609 | |
1610 | int |
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 | |
1628 | int |
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 | |
1646 | void |
1647 | __glXDispSwap_PixelMapfv(GLbyte * pc) |
1648 | { |
1649 | const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4); |
1650 | |
1651 | glPixelMapfv((GLenum) bswap_ENUM(pc + 0), |
1652 | mapsize, |
1653 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), 0)); |
1654 | } |
1655 | |
1656 | void |
1657 | __glXDispSwap_PixelMapuiv(GLbyte * pc) |
1658 | { |
1659 | const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4); |
1660 | |
1661 | glPixelMapuiv((GLenum) bswap_ENUM(pc + 0), |
1662 | mapsize, |
1663 | (const GLuint *) bswap_32_array((uint32_t *) (pc + 8), 0)); |
1664 | } |
1665 | |
1666 | void |
1667 | __glXDispSwap_PixelMapusv(GLbyte * pc) |
1668 | { |
1669 | const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4); |
1670 | |
1671 | glPixelMapusv((GLenum) bswap_ENUM(pc + 0), |
1672 | mapsize, |
1673 | (const GLushort *) bswap_16_array((uint16_t *) (pc + 8), 0)); |
1674 | } |
1675 | |
1676 | void |
1677 | __glXDispSwap_ReadBuffer(GLbyte * pc) |
1678 | { |
1679 | glReadBuffer((GLenum) bswap_ENUM(pc + 0)); |
1680 | } |
1681 | |
1682 | void |
1683 | __glXDispSwap_CopyPixels(GLbyte * pc) |
1684 | { |
1685 | glCopyPixels((GLint) bswap_CARD32(pc + 0), |
1686 | (GLint) bswap_CARD32(pc + 4), |
1687 | (GLsizei) bswap_CARD32(pc + 8), |
1688 | (GLsizei) bswap_CARD32(pc + 12), (GLenum) bswap_ENUM(pc + 16)); |
1689 | } |
1690 | |
1691 | void |
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 | |
1711 | int |
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 | |
1741 | int |
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 | |
1762 | int |
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 | |
1793 | int |
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 | |
1813 | int |
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 | |
1844 | int |
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 | |
1875 | int |
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 | |
1906 | int |
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 | |
1937 | int |
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 | |
1969 | int |
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 | |
2001 | int |
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 | |
2033 | int |
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 | |
2064 | int |
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 | |
2095 | int |
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 | |
2126 | int |
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 | |
2157 | int |
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 | |
2188 | int |
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 | |
2219 | int |
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 | |
2250 | int |
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 | |
2281 | int |
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 | |
2312 | int |
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 | |
2343 | int |
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 | |
2374 | int |
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 | |
2405 | int |
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 | |
2437 | int |
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 | |
2469 | int |
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 | |
2489 | int |
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 | |
2509 | void |
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 | |
2523 | void |
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 | |
2541 | void |
2542 | __glXDispSwap_LoadIdentity(GLbyte * pc) |
2543 | { |
2544 | glLoadIdentity(); |
2545 | } |
2546 | |
2547 | void |
2548 | __glXDispSwap_LoadMatrixf(GLbyte * pc) |
2549 | { |
2550 | glLoadMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16)); |
2551 | } |
2552 | |
2553 | void |
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 | |
2566 | void |
2567 | __glXDispSwap_MatrixMode(GLbyte * pc) |
2568 | { |
2569 | glMatrixMode((GLenum) bswap_ENUM(pc + 0)); |
2570 | } |
2571 | |
2572 | void |
2573 | __glXDispSwap_MultMatrixf(GLbyte * pc) |
2574 | { |
2575 | glMultMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16)); |
2576 | } |
2577 | |
2578 | void |
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 | |
2591 | void |
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 | |
2609 | void |
2610 | __glXDispSwap_PopMatrix(GLbyte * pc) |
2611 | { |
2612 | glPopMatrix(); |
2613 | } |
2614 | |
2615 | void |
2616 | __glXDispSwap_PushMatrix(GLbyte * pc) |
2617 | { |
2618 | glPushMatrix(); |
2619 | } |
2620 | |
2621 | void |
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 | |
2637 | void |
2638 | __glXDispSwap_Rotatef(GLbyte * pc) |
2639 | { |
2640 | glRotatef((GLfloat) bswap_FLOAT32(pc + 0), |
2641 | (GLfloat) bswap_FLOAT32(pc + 4), |
2642 | (GLfloat) bswap_FLOAT32(pc + 8), |
2643 | (GLfloat) bswap_FLOAT32(pc + 12)); |
2644 | } |
2645 | |
2646 | void |
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 | |
2661 | void |
2662 | __glXDispSwap_Scalef(GLbyte * pc) |
2663 | { |
2664 | glScalef((GLfloat) bswap_FLOAT32(pc + 0), |
2665 | (GLfloat) bswap_FLOAT32(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8)); |
2666 | } |
2667 | |
2668 | void |
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 | |
2683 | void |
2684 | __glXDispSwap_Translatef(GLbyte * pc) |
2685 | { |
2686 | glTranslatef((GLfloat) bswap_FLOAT32(pc + 0), |
2687 | (GLfloat) bswap_FLOAT32(pc + 4), |
2688 | (GLfloat) bswap_FLOAT32(pc + 8)); |
2689 | } |
2690 | |
2691 | void |
2692 | __glXDispSwap_Viewport(GLbyte * pc) |
2693 | { |
2694 | glViewport((GLint) bswap_CARD32(pc + 0), |
2695 | (GLint) bswap_CARD32(pc + 4), |
2696 | (GLsizei) bswap_CARD32(pc + 8), (GLsizei) bswap_CARD32(pc + 12)); |
2697 | } |
2698 | |
2699 | void |
2700 | __glXDispSwap_BindTexture(GLbyte * pc) |
2701 | { |
2702 | glBindTexture((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4)); |
2703 | } |
2704 | |
2705 | void |
2706 | __glXDispSwap_Indexubv(GLbyte * pc) |
2707 | { |
2708 | glIndexubv((const GLubyte *) (pc + 0)); |
2709 | } |
2710 | |
2711 | void |
2712 | __glXDispSwap_PolygonOffset(GLbyte * pc) |
2713 | { |
2714 | glPolygonOffset((GLfloat) bswap_FLOAT32(pc + 0), |
2715 | (GLfloat) bswap_FLOAT32(pc + 4)); |
2716 | } |
2717 | |
2718 | int |
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 | |
2749 | int |
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 | |
2780 | void |
2781 | __glXDispSwap_CopyTexImage1D(GLbyte * pc) |
2782 | { |
2783 | glCopyTexImage1D((GLenum) bswap_ENUM(pc + 0), |
2784 | (GLint) bswap_CARD32(pc + 4), |
2785 | (GLenum) bswap_ENUM(pc + 8), |
2786 | (GLint) bswap_CARD32(pc + 12), |
2787 | (GLint) bswap_CARD32(pc + 16), |
2788 | (GLsizei) bswap_CARD32(pc + 20), |
2789 | (GLint) bswap_CARD32(pc + 24)); |
2790 | } |
2791 | |
2792 | void |
2793 | __glXDispSwap_CopyTexImage2D(GLbyte * pc) |
2794 | { |
2795 | glCopyTexImage2D((GLenum) bswap_ENUM(pc + 0), |
2796 | (GLint) bswap_CARD32(pc + 4), |
2797 | (GLenum) bswap_ENUM(pc + 8), |
2798 | (GLint) bswap_CARD32(pc + 12), |
2799 | (GLint) bswap_CARD32(pc + 16), |
2800 | (GLsizei) bswap_CARD32(pc + 20), |
2801 | (GLsizei) bswap_CARD32(pc + 24), |
2802 | (GLint) bswap_CARD32(pc + 28)); |
2803 | } |
2804 | |
2805 | void |
2806 | __glXDispSwap_CopyTexSubImage1D(GLbyte * pc) |
2807 | { |
2808 | glCopyTexSubImage1D((GLenum) bswap_ENUM(pc + 0), |
2809 | (GLint) bswap_CARD32(pc + 4), |
2810 | (GLint) bswap_CARD32(pc + 8), |
2811 | (GLint) bswap_CARD32(pc + 12), |
2812 | (GLint) bswap_CARD32(pc + 16), |
2813 | (GLsizei) bswap_CARD32(pc + 20)); |
2814 | } |
2815 | |
2816 | void |
2817 | __glXDispSwap_CopyTexSubImage2D(GLbyte * pc) |
2818 | { |
2819 | glCopyTexSubImage2D((GLenum) bswap_ENUM(pc + 0), |
2820 | (GLint) bswap_CARD32(pc + 4), |
2821 | (GLint) bswap_CARD32(pc + 8), |
2822 | (GLint) bswap_CARD32(pc + 12), |
2823 | (GLint) bswap_CARD32(pc + 16), |
2824 | (GLint) bswap_CARD32(pc + 20), |
2825 | (GLsizei) bswap_CARD32(pc + 24), |
2826 | (GLsizei) bswap_CARD32(pc + 28)); |
2827 | } |
2828 | |
2829 | int |
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 | |
2850 | int |
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 | |
2871 | int |
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 | |
2899 | int |
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 | |
2927 | int |
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 | |
2947 | int |
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 | |
2967 | void |
2968 | __glXDispSwap_PrioritizeTextures(GLbyte * pc) |
2969 | { |
2970 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 0); |
2971 | |
2972 | glPrioritizeTextures(n, |
2973 | (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), |
2974 | 0), |
2975 | (const GLclampf *) |
2976 | bswap_32_array((uint32_t *) (pc + 4), 0)); |
2977 | } |
2978 | |
2979 | void |
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 | |
3001 | void |
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 | |
3025 | void |
3026 | __glXDispSwap_BlendColor(GLbyte * pc) |
3027 | { |
3028 | glBlendColor((GLclampf) bswap_FLOAT32(pc + 0), |
3029 | (GLclampf) bswap_FLOAT32(pc + 4), |
3030 | (GLclampf) bswap_FLOAT32(pc + 8), |
3031 | (GLclampf) bswap_FLOAT32(pc + 12)); |
3032 | } |
3033 | |
3034 | void |
3035 | __glXDispSwap_BlendEquation(GLbyte * pc) |
3036 | { |
3037 | glBlendEquation((GLenum) bswap_ENUM(pc + 0)); |
3038 | } |
3039 | |
3040 | void |
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 | |
3061 | void |
3062 | __glXDispSwap_ColorTableParameterfv(GLbyte * pc) |
3063 | { |
3064 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
3065 | const GLfloat *params; |
3066 | |
3067 | params = |
3068 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
3069 | __glColorTableParameterfv_size(pname)); |
3070 | |
3071 | glColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
3072 | } |
3073 | |
3074 | void |
3075 | __glXDispSwap_ColorTableParameteriv(GLbyte * pc) |
3076 | { |
3077 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
3078 | const GLint *params; |
3079 | |
3080 | params = |
3081 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
3082 | __glColorTableParameteriv_size(pname)); |
3083 | |
3084 | glColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params); |
3085 | } |
3086 | |
3087 | void |
3088 | __glXDispSwap_CopyColorTable(GLbyte * pc) |
3089 | { |
3090 | glCopyColorTable((GLenum) bswap_ENUM(pc + 0), |
3091 | (GLenum) bswap_ENUM(pc + 4), |
3092 | (GLint) bswap_CARD32(pc + 8), |
3093 | (GLint) bswap_CARD32(pc + 12), |
3094 | (GLsizei) bswap_CARD32(pc + 16)); |
3095 | } |
3096 | |
3097 | int |
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 | |
3128 | int |
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 | |
3159 | int |
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 | |
3190 | int |
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 | |
3221 | void |
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 | |
3242 | void |
3243 | __glXDispSwap_CopyColorSubTable(GLbyte * pc) |
3244 | { |
3245 | glCopyColorSubTable((GLenum) bswap_ENUM(pc + 0), |
3246 | (GLsizei) bswap_CARD32(pc + 4), |
3247 | (GLint) bswap_CARD32(pc + 8), |
3248 | (GLint) bswap_CARD32(pc + 12), |
3249 | (GLsizei) bswap_CARD32(pc + 16)); |
3250 | } |
3251 | |
3252 | void |
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 | |
3273 | void |
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 | |
3295 | void |
3296 | __glXDispSwap_ConvolutionParameterf(GLbyte * pc) |
3297 | { |
3298 | glConvolutionParameterf((GLenum) bswap_ENUM(pc + 0), |
3299 | (GLenum) bswap_ENUM(pc + 4), |
3300 | (GLfloat) bswap_FLOAT32(pc + 8)); |
3301 | } |
3302 | |
3303 | void |
3304 | __glXDispSwap_ConvolutionParameterfv(GLbyte * pc) |
3305 | { |
3306 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
3307 | const GLfloat *params; |
3308 | |
3309 | params = |
3310 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
3311 | __glConvolutionParameterfv_size |
3312 | (pname)); |
3313 | |
3314 | glConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params); |
3315 | } |
3316 | |
3317 | void |
3318 | __glXDispSwap_ConvolutionParameteri(GLbyte * pc) |
3319 | { |
3320 | glConvolutionParameteri((GLenum) bswap_ENUM(pc + 0), |
3321 | (GLenum) bswap_ENUM(pc + 4), |
3322 | (GLint) bswap_CARD32(pc + 8)); |
3323 | } |
3324 | |
3325 | void |
3326 | __glXDispSwap_ConvolutionParameteriv(GLbyte * pc) |
3327 | { |
3328 | const GLenum pname = (GLenum) bswap_ENUM(pc + 4); |
3329 | const GLint *params; |
3330 | |
3331 | params = |
3332 | (const GLint *) bswap_32_array((uint32_t *) (pc + 8), |
3333 | __glConvolutionParameteriv_size(pname)); |
3334 | |
3335 | glConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params); |
3336 | } |
3337 | |
3338 | void |
3339 | __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc) |
3340 | { |
3341 | glCopyConvolutionFilter1D((GLenum) bswap_ENUM(pc + 0), |
3342 | (GLenum) bswap_ENUM(pc + 4), |
3343 | (GLint) bswap_CARD32(pc + 8), |
3344 | (GLint) bswap_CARD32(pc + 12), |
3345 | (GLsizei) bswap_CARD32(pc + 16)); |
3346 | } |
3347 | |
3348 | void |
3349 | __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc) |
3350 | { |
3351 | glCopyConvolutionFilter2D((GLenum) bswap_ENUM(pc + 0), |
3352 | (GLenum) bswap_ENUM(pc + 4), |
3353 | (GLint) bswap_CARD32(pc + 8), |
3354 | (GLint) bswap_CARD32(pc + 12), |
3355 | (GLsizei) bswap_CARD32(pc + 16), |
3356 | (GLsizei) bswap_CARD32(pc + 20)); |
3357 | } |
3358 | |
3359 | int |
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 | |
3390 | int |
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 | |
3421 | int |
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 | |
3452 | int |
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 | |
3483 | int |
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 | |
3514 | int |
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 | |
3545 | int |
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 | |
3576 | int |
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 | |
3607 | int |
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 | |
3638 | int |
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 | |
3669 | int |
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 | |
3700 | int |
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 | |
3731 | void |
3732 | __glXDispSwap_Histogram(GLbyte * pc) |
3733 | { |
3734 | glHistogram((GLenum) bswap_ENUM(pc + 0), |
3735 | (GLsizei) bswap_CARD32(pc + 4), |
3736 | (GLenum) bswap_ENUM(pc + 8), *(GLboolean *) (pc + 12)); |
3737 | } |
3738 | |
3739 | void |
3740 | __glXDispSwap_Minmax(GLbyte * pc) |
3741 | { |
3742 | glMinmax((GLenum) bswap_ENUM(pc + 0), |
3743 | (GLenum) bswap_ENUM(pc + 4), *(GLboolean *) (pc + 8)); |
3744 | } |
3745 | |
3746 | void |
3747 | __glXDispSwap_ResetHistogram(GLbyte * pc) |
3748 | { |
3749 | glResetHistogram((GLenum) bswap_ENUM(pc + 0)); |
3750 | } |
3751 | |
3752 | void |
3753 | __glXDispSwap_ResetMinmax(GLbyte * pc) |
3754 | { |
3755 | glResetMinmax((GLenum) bswap_ENUM(pc + 0)); |
3756 | } |
3757 | |
3758 | void |
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 | |
3789 | void |
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 | |
3819 | void |
3820 | __glXDispSwap_CopyTexSubImage3D(GLbyte * pc) |
3821 | { |
3822 | glCopyTexSubImage3D((GLenum) bswap_ENUM(pc + 0), |
3823 | (GLint) bswap_CARD32(pc + 4), |
3824 | (GLint) bswap_CARD32(pc + 8), |
3825 | (GLint) bswap_CARD32(pc + 12), |
3826 | (GLint) bswap_CARD32(pc + 16), |
3827 | (GLint) bswap_CARD32(pc + 20), |
3828 | (GLint) bswap_CARD32(pc + 24), |
3829 | (GLsizei) bswap_CARD32(pc + 28), |
3830 | (GLsizei) bswap_CARD32(pc + 32)); |
3831 | } |
3832 | |
3833 | void |
3834 | __glXDispSwap_ActiveTexture(GLbyte * pc) |
3835 | { |
3836 | glActiveTextureARB((GLenum) bswap_ENUM(pc + 0)); |
3837 | } |
3838 | |
3839 | void |
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 | |
3854 | void |
3855 | __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc) |
3856 | { |
3857 | glMultiTexCoord1fvARB((GLenum) bswap_ENUM(pc + 0), |
3858 | (const GLfloat *) |
3859 | bswap_32_array((uint32_t *) (pc + 4), 1)); |
3860 | } |
3861 | |
3862 | void |
3863 | __glXDispSwap_MultiTexCoord1iv(GLbyte * pc) |
3864 | { |
3865 | glMultiTexCoord1ivARB((GLenum) bswap_ENUM(pc + 0), |
3866 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
3867 | 1)); |
3868 | } |
3869 | |
3870 | void |
3871 | __glXDispSwap_MultiTexCoord1sv(GLbyte * pc) |
3872 | { |
3873 | glMultiTexCoord1svARB((GLenum) bswap_ENUM(pc + 0), |
3874 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
3875 | 1)); |
3876 | } |
3877 | |
3878 | void |
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 | |
3893 | void |
3894 | __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc) |
3895 | { |
3896 | glMultiTexCoord2fvARB((GLenum) bswap_ENUM(pc + 0), |
3897 | (const GLfloat *) |
3898 | bswap_32_array((uint32_t *) (pc + 4), 2)); |
3899 | } |
3900 | |
3901 | void |
3902 | __glXDispSwap_MultiTexCoord2iv(GLbyte * pc) |
3903 | { |
3904 | glMultiTexCoord2ivARB((GLenum) bswap_ENUM(pc + 0), |
3905 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
3906 | 2)); |
3907 | } |
3908 | |
3909 | void |
3910 | __glXDispSwap_MultiTexCoord2sv(GLbyte * pc) |
3911 | { |
3912 | glMultiTexCoord2svARB((GLenum) bswap_ENUM(pc + 0), |
3913 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
3914 | 2)); |
3915 | } |
3916 | |
3917 | void |
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 | |
3932 | void |
3933 | __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc) |
3934 | { |
3935 | glMultiTexCoord3fvARB((GLenum) bswap_ENUM(pc + 0), |
3936 | (const GLfloat *) |
3937 | bswap_32_array((uint32_t *) (pc + 4), 3)); |
3938 | } |
3939 | |
3940 | void |
3941 | __glXDispSwap_MultiTexCoord3iv(GLbyte * pc) |
3942 | { |
3943 | glMultiTexCoord3ivARB((GLenum) bswap_ENUM(pc + 0), |
3944 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
3945 | 3)); |
3946 | } |
3947 | |
3948 | void |
3949 | __glXDispSwap_MultiTexCoord3sv(GLbyte * pc) |
3950 | { |
3951 | glMultiTexCoord3svARB((GLenum) bswap_ENUM(pc + 0), |
3952 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
3953 | 3)); |
3954 | } |
3955 | |
3956 | void |
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 | |
3971 | void |
3972 | __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc) |
3973 | { |
3974 | glMultiTexCoord4fvARB((GLenum) bswap_ENUM(pc + 0), |
3975 | (const GLfloat *) |
3976 | bswap_32_array((uint32_t *) (pc + 4), 4)); |
3977 | } |
3978 | |
3979 | void |
3980 | __glXDispSwap_MultiTexCoord4iv(GLbyte * pc) |
3981 | { |
3982 | glMultiTexCoord4ivARB((GLenum) bswap_ENUM(pc + 0), |
3983 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
3984 | 4)); |
3985 | } |
3986 | |
3987 | void |
3988 | __glXDispSwap_MultiTexCoord4sv(GLbyte * pc) |
3989 | { |
3990 | glMultiTexCoord4svARB((GLenum) bswap_ENUM(pc + 0), |
3991 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
3992 | 4)); |
3993 | } |
3994 | |
3995 | void |
3996 | __glXDispSwap_CompressedTexImage1D(GLbyte * pc) |
3997 | { |
3998 | PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D = |
3999 | __glGetProcAddress("glCompressedTexImage1D"); |
4000 | const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20); |
4001 | |
4002 | CompressedTexImage1D((GLenum) bswap_ENUM(pc + 0), |
4003 | (GLint) bswap_CARD32(pc + 4), |
4004 | (GLenum) bswap_ENUM(pc + 8), |
4005 | (GLsizei) bswap_CARD32(pc + 12), |
4006 | (GLint) bswap_CARD32(pc + 16), |
4007 | imageSize, (const GLvoid *) (pc + 24)); |
4008 | } |
4009 | |
4010 | void |
4011 | __glXDispSwap_CompressedTexImage2D(GLbyte * pc) |
4012 | { |
4013 | PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D = |
4014 | __glGetProcAddress("glCompressedTexImage2D"); |
4015 | const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 24); |
4016 | |
4017 | CompressedTexImage2D((GLenum) bswap_ENUM(pc + 0), |
4018 | (GLint) bswap_CARD32(pc + 4), |
4019 | (GLenum) bswap_ENUM(pc + 8), |
4020 | (GLsizei) bswap_CARD32(pc + 12), |
4021 | (GLsizei) bswap_CARD32(pc + 16), |
4022 | (GLint) bswap_CARD32(pc + 20), |
4023 | imageSize, (const GLvoid *) (pc + 28)); |
4024 | } |
4025 | |
4026 | void |
4027 | __glXDispSwap_CompressedTexImage3D(GLbyte * pc) |
4028 | { |
4029 | PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D = |
4030 | __glGetProcAddress("glCompressedTexImage3D"); |
4031 | const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28); |
4032 | |
4033 | CompressedTexImage3D((GLenum) bswap_ENUM(pc + 0), |
4034 | (GLint) bswap_CARD32(pc + 4), |
4035 | (GLenum) bswap_ENUM(pc + 8), |
4036 | (GLsizei) bswap_CARD32(pc + 12), |
4037 | (GLsizei) bswap_CARD32(pc + 16), |
4038 | (GLsizei) bswap_CARD32(pc + 20), |
4039 | (GLint) bswap_CARD32(pc + 24), |
4040 | imageSize, (const GLvoid *) (pc + 32)); |
4041 | } |
4042 | |
4043 | void |
4044 | __glXDispSwap_CompressedTexSubImage1D(GLbyte * pc) |
4045 | { |
4046 | PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D = |
4047 | __glGetProcAddress("glCompressedTexSubImage1D"); |
4048 | const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20); |
4049 | |
4050 | CompressedTexSubImage1D((GLenum) bswap_ENUM(pc + 0), |
4051 | (GLint) bswap_CARD32(pc + 4), |
4052 | (GLint) bswap_CARD32(pc + 8), |
4053 | (GLsizei) bswap_CARD32(pc + 12), |
4054 | (GLenum) bswap_ENUM(pc + 16), |
4055 | imageSize, (const GLvoid *) (pc + 24)); |
4056 | } |
4057 | |
4058 | void |
4059 | __glXDispSwap_CompressedTexSubImage2D(GLbyte * pc) |
4060 | { |
4061 | PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D = |
4062 | __glGetProcAddress("glCompressedTexSubImage2D"); |
4063 | const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28); |
4064 | |
4065 | CompressedTexSubImage2D((GLenum) bswap_ENUM(pc + 0), |
4066 | (GLint) bswap_CARD32(pc + 4), |
4067 | (GLint) bswap_CARD32(pc + 8), |
4068 | (GLint) bswap_CARD32(pc + 12), |
4069 | (GLsizei) bswap_CARD32(pc + 16), |
4070 | (GLsizei) bswap_CARD32(pc + 20), |
4071 | (GLenum) bswap_ENUM(pc + 24), |
4072 | imageSize, (const GLvoid *) (pc + 32)); |
4073 | } |
4074 | |
4075 | void |
4076 | __glXDispSwap_CompressedTexSubImage3D(GLbyte * pc) |
4077 | { |
4078 | PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D = |
4079 | __glGetProcAddress("glCompressedTexSubImage3D"); |
4080 | const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 36); |
4081 | |
4082 | CompressedTexSubImage3D((GLenum) bswap_ENUM(pc + 0), |
4083 | (GLint) bswap_CARD32(pc + 4), |
4084 | (GLint) bswap_CARD32(pc + 8), |
4085 | (GLint) bswap_CARD32(pc + 12), |
4086 | (GLint) bswap_CARD32(pc + 16), |
4087 | (GLsizei) bswap_CARD32(pc + 20), |
4088 | (GLsizei) bswap_CARD32(pc + 24), |
4089 | (GLsizei) bswap_CARD32(pc + 28), |
4090 | (GLenum) bswap_ENUM(pc + 32), |
4091 | imageSize, (const GLvoid *) (pc + 40)); |
4092 | } |
4093 | |
4094 | void |
4095 | __glXDispSwap_SampleCoverage(GLbyte * pc) |
4096 | { |
4097 | PFNGLSAMPLECOVERAGEPROC SampleCoverage = |
4098 | __glGetProcAddress("glSampleCoverage"); |
4099 | SampleCoverage((GLclampf) bswap_FLOAT32(pc + 0), *(GLboolean *) (pc + 4)); |
4100 | } |
4101 | |
4102 | void |
4103 | __glXDispSwap_BlendFuncSeparate(GLbyte * pc) |
4104 | { |
4105 | PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate = |
4106 | __glGetProcAddress("glBlendFuncSeparate"); |
4107 | BlendFuncSeparate((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4), |
4108 | (GLenum) bswap_ENUM(pc + 8), |
4109 | (GLenum) bswap_ENUM(pc + 12)); |
4110 | } |
4111 | |
4112 | void |
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 | |
4127 | void |
4128 | __glXDispSwap_PointParameterf(GLbyte * pc) |
4129 | { |
4130 | PFNGLPOINTPARAMETERFPROC PointParameterf = |
4131 | __glGetProcAddress("glPointParameterf"); |
4132 | PointParameterf((GLenum) bswap_ENUM(pc + 0), |
4133 | (GLfloat) bswap_FLOAT32(pc + 4)); |
4134 | } |
4135 | |
4136 | void |
4137 | __glXDispSwap_PointParameterfv(GLbyte * pc) |
4138 | { |
4139 | PFNGLPOINTPARAMETERFVPROC PointParameterfv = |
4140 | __glGetProcAddress("glPointParameterfv"); |
4141 | const GLenum pname = (GLenum) bswap_ENUM(pc + 0); |
4142 | const GLfloat *params; |
4143 | |
4144 | params = |
4145 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
4146 | __glPointParameterfv_size(pname)); |
4147 | |
4148 | PointParameterfv(pname, params); |
4149 | } |
4150 | |
4151 | void |
4152 | __glXDispSwap_PointParameteri(GLbyte * pc) |
4153 | { |
4154 | PFNGLPOINTPARAMETERIPROC PointParameteri = |
4155 | __glGetProcAddress("glPointParameteri"); |
4156 | PointParameteri((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4)); |
4157 | } |
4158 | |
4159 | void |
4160 | __glXDispSwap_PointParameteriv(GLbyte * pc) |
4161 | { |
4162 | PFNGLPOINTPARAMETERIVPROC PointParameteriv = |
4163 | __glGetProcAddress("glPointParameteriv"); |
4164 | const GLenum pname = (GLenum) bswap_ENUM(pc + 0); |
4165 | const GLint *params; |
4166 | |
4167 | params = |
4168 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), |
4169 | __glPointParameteriv_size(pname)); |
4170 | |
4171 | PointParameteriv(pname, params); |
4172 | } |
4173 | |
4174 | void |
4175 | __glXDispSwap_SecondaryColor3bv(GLbyte * pc) |
4176 | { |
4177 | PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv = |
4178 | __glGetProcAddress("glSecondaryColor3bv"); |
4179 | SecondaryColor3bv((const GLbyte *) (pc + 0)); |
4180 | } |
4181 | |
4182 | void |
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 | |
4198 | void |
4199 | __glXDispSwap_SecondaryColor3iv(GLbyte * pc) |
4200 | { |
4201 | PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv = |
4202 | __glGetProcAddress("glSecondaryColor3iv"); |
4203 | SecondaryColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
4204 | } |
4205 | |
4206 | void |
4207 | __glXDispSwap_SecondaryColor3sv(GLbyte * pc) |
4208 | { |
4209 | PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv = |
4210 | __glGetProcAddress("glSecondaryColor3sv"); |
4211 | SecondaryColor3sv((const GLshort *) |
4212 | bswap_16_array((uint16_t *) (pc + 0), 3)); |
4213 | } |
4214 | |
4215 | void |
4216 | __glXDispSwap_SecondaryColor3ubv(GLbyte * pc) |
4217 | { |
4218 | PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv = |
4219 | __glGetProcAddress("glSecondaryColor3ubv"); |
4220 | SecondaryColor3ubv((const GLubyte *) (pc + 0)); |
4221 | } |
4222 | |
4223 | void |
4224 | __glXDispSwap_SecondaryColor3uiv(GLbyte * pc) |
4225 | { |
4226 | PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv = |
4227 | __glGetProcAddress("glSecondaryColor3uiv"); |
4228 | SecondaryColor3uiv((const GLuint *) |
4229 | bswap_32_array((uint32_t *) (pc + 0), 3)); |
4230 | } |
4231 | |
4232 | void |
4233 | __glXDispSwap_SecondaryColor3usv(GLbyte * pc) |
4234 | { |
4235 | PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv = |
4236 | __glGetProcAddress("glSecondaryColor3usv"); |
4237 | SecondaryColor3usv((const GLushort *) |
4238 | bswap_16_array((uint16_t *) (pc + 0), 3)); |
4239 | } |
4240 | |
4241 | void |
4242 | __glXDispSwap_WindowPos3fv(GLbyte * pc) |
4243 | { |
4244 | PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv"); |
4245 | |
4246 | WindowPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3)); |
4247 | } |
4248 | |
4249 | void |
4250 | __glXDispSwap_BeginQuery(GLbyte * pc) |
4251 | { |
4252 | PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery"); |
4253 | |
4254 | BeginQuery((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4)); |
4255 | } |
4256 | |
4257 | int |
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 | |
4280 | void |
4281 | __glXDispSwap_EndQuery(GLbyte * pc) |
4282 | { |
4283 | PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery"); |
4284 | |
4285 | EndQuery((GLenum) bswap_ENUM(pc + 0)); |
4286 | } |
4287 | |
4288 | int |
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 | |
4317 | int |
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 | |
4350 | int |
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 | |
4383 | int |
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 | |
4415 | int |
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 | |
4436 | void |
4437 | __glXDispSwap_BlendEquationSeparate(GLbyte * pc) |
4438 | { |
4439 | PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate = |
4440 | __glGetProcAddress("glBlendEquationSeparate"); |
4441 | BlendEquationSeparate((GLenum) bswap_ENUM(pc + 0), |
4442 | (GLenum) bswap_ENUM(pc + 4)); |
4443 | } |
4444 | |
4445 | void |
4446 | __glXDispSwap_DrawBuffers(GLbyte * pc) |
4447 | { |
4448 | PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers"); |
4449 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 0); |
4450 | |
4451 | DrawBuffers(n, (const GLenum *) bswap_32_array((uint32_t *) (pc + 4), 0)); |
4452 | } |
4453 | |
4454 | void |
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 | |
4471 | void |
4472 | __glXDispSwap_VertexAttrib1sv(GLbyte * pc) |
4473 | { |
4474 | PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv = |
4475 | __glGetProcAddress("glVertexAttrib1sv"); |
4476 | VertexAttrib1sv((GLuint) bswap_CARD32(pc + 0), |
4477 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 1)); |
4478 | } |
4479 | |
4480 | void |
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 | |
4497 | void |
4498 | __glXDispSwap_VertexAttrib2sv(GLbyte * pc) |
4499 | { |
4500 | PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv = |
4501 | __glGetProcAddress("glVertexAttrib2sv"); |
4502 | VertexAttrib2sv((GLuint) bswap_CARD32(pc + 0), |
4503 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2)); |
4504 | } |
4505 | |
4506 | void |
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 | |
4523 | void |
4524 | __glXDispSwap_VertexAttrib3sv(GLbyte * pc) |
4525 | { |
4526 | PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv = |
4527 | __glGetProcAddress("glVertexAttrib3sv"); |
4528 | VertexAttrib3sv((GLuint) bswap_CARD32(pc + 0), |
4529 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 3)); |
4530 | } |
4531 | |
4532 | void |
4533 | __glXDispSwap_VertexAttrib4Nbv(GLbyte * pc) |
4534 | { |
4535 | PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv = |
4536 | __glGetProcAddress("glVertexAttrib4Nbv"); |
4537 | VertexAttrib4Nbv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4)); |
4538 | } |
4539 | |
4540 | void |
4541 | __glXDispSwap_VertexAttrib4Niv(GLbyte * pc) |
4542 | { |
4543 | PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv = |
4544 | __glGetProcAddress("glVertexAttrib4Niv"); |
4545 | VertexAttrib4Niv((GLuint) bswap_CARD32(pc + 0), |
4546 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4)); |
4547 | } |
4548 | |
4549 | void |
4550 | __glXDispSwap_VertexAttrib4Nsv(GLbyte * pc) |
4551 | { |
4552 | PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv = |
4553 | __glGetProcAddress("glVertexAttrib4Nsv"); |
4554 | VertexAttrib4Nsv((GLuint) bswap_CARD32(pc + 0), |
4555 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
4556 | 4)); |
4557 | } |
4558 | |
4559 | void |
4560 | __glXDispSwap_VertexAttrib4Nubv(GLbyte * pc) |
4561 | { |
4562 | PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv = |
4563 | __glGetProcAddress("glVertexAttrib4Nubv"); |
4564 | VertexAttrib4Nubv((GLuint) bswap_CARD32(pc + 0), |
4565 | (const GLubyte *) (pc + 4)); |
4566 | } |
4567 | |
4568 | void |
4569 | __glXDispSwap_VertexAttrib4Nuiv(GLbyte * pc) |
4570 | { |
4571 | PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv = |
4572 | __glGetProcAddress("glVertexAttrib4Nuiv"); |
4573 | VertexAttrib4Nuiv((GLuint) bswap_CARD32(pc + 0), |
4574 | (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), |
4575 | 4)); |
4576 | } |
4577 | |
4578 | void |
4579 | __glXDispSwap_VertexAttrib4Nusv(GLbyte * pc) |
4580 | { |
4581 | PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv = |
4582 | __glGetProcAddress("glVertexAttrib4Nusv"); |
4583 | VertexAttrib4Nusv((GLuint) bswap_CARD32(pc + 0), |
4584 | (const GLushort *) bswap_16_array((uint16_t *) (pc + 4), |
4585 | 4)); |
4586 | } |
4587 | |
4588 | void |
4589 | __glXDispSwap_VertexAttrib4bv(GLbyte * pc) |
4590 | { |
4591 | PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv = |
4592 | __glGetProcAddress("glVertexAttrib4bv"); |
4593 | VertexAttrib4bv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4)); |
4594 | } |
4595 | |
4596 | void |
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 | |
4613 | void |
4614 | __glXDispSwap_VertexAttrib4iv(GLbyte * pc) |
4615 | { |
4616 | PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv = |
4617 | __glGetProcAddress("glVertexAttrib4iv"); |
4618 | VertexAttrib4iv((GLuint) bswap_CARD32(pc + 0), |
4619 | (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4)); |
4620 | } |
4621 | |
4622 | void |
4623 | __glXDispSwap_VertexAttrib4sv(GLbyte * pc) |
4624 | { |
4625 | PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv = |
4626 | __glGetProcAddress("glVertexAttrib4sv"); |
4627 | VertexAttrib4sv((GLuint) bswap_CARD32(pc + 0), |
4628 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 4)); |
4629 | } |
4630 | |
4631 | void |
4632 | __glXDispSwap_VertexAttrib4ubv(GLbyte * pc) |
4633 | { |
4634 | PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv = |
4635 | __glGetProcAddress("glVertexAttrib4ubv"); |
4636 | VertexAttrib4ubv((GLuint) bswap_CARD32(pc + 0), (const GLubyte *) (pc + 4)); |
4637 | } |
4638 | |
4639 | void |
4640 | __glXDispSwap_VertexAttrib4uiv(GLbyte * pc) |
4641 | { |
4642 | PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv = |
4643 | __glGetProcAddress("glVertexAttrib4uiv"); |
4644 | VertexAttrib4uiv((GLuint) bswap_CARD32(pc + 0), |
4645 | (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), 4)); |
4646 | } |
4647 | |
4648 | void |
4649 | __glXDispSwap_VertexAttrib4usv(GLbyte * pc) |
4650 | { |
4651 | PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv = |
4652 | __glGetProcAddress("glVertexAttrib4usv"); |
4653 | VertexAttrib4usv((GLuint) bswap_CARD32(pc + 0), |
4654 | (const GLushort *) bswap_16_array((uint16_t *) (pc + 4), |
4655 | 4)); |
4656 | } |
4657 | |
4658 | void |
4659 | __glXDispSwap_ClampColor(GLbyte * pc) |
4660 | { |
4661 | PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor"); |
4662 | |
4663 | ClampColor((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4)); |
4664 | } |
4665 | |
4666 | void |
4667 | __glXDispSwap_BindProgramARB(GLbyte * pc) |
4668 | { |
4669 | PFNGLBINDPROGRAMARBPROC BindProgramARB = |
4670 | __glGetProcAddress("glBindProgramARB"); |
4671 | BindProgramARB((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4)); |
4672 | } |
4673 | |
4674 | int |
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 | |
4697 | int |
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 | |
4727 | int |
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 | |
4751 | int |
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 | |
4775 | int |
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 | |
4799 | int |
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 | |
4823 | int |
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 | |
4856 | int |
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 | |
4877 | void |
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 | |
4895 | void |
4896 | __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc) |
4897 | { |
4898 | PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB = |
4899 | __glGetProcAddress("glProgramEnvParameter4fvARB"); |
4900 | ProgramEnvParameter4fvARB((GLenum) bswap_ENUM(pc + 0), |
4901 | (GLuint) bswap_CARD32(pc + 4), |
4902 | (const GLfloat *) |
4903 | bswap_32_array((uint32_t *) (pc + 8), 4)); |
4904 | } |
4905 | |
4906 | void |
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 | |
4924 | void |
4925 | __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc) |
4926 | { |
4927 | PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB = |
4928 | __glGetProcAddress("glProgramLocalParameter4fvARB"); |
4929 | ProgramLocalParameter4fvARB((GLenum) bswap_ENUM(pc + 0), |
4930 | (GLuint) bswap_CARD32(pc + 4), |
4931 | (const GLfloat *) |
4932 | bswap_32_array((uint32_t *) (pc + 8), 4)); |
4933 | } |
4934 | |
4935 | void |
4936 | __glXDispSwap_ProgramStringARB(GLbyte * pc) |
4937 | { |
4938 | PFNGLPROGRAMSTRINGARBPROC ProgramStringARB = |
4939 | __glGetProcAddress("glProgramStringARB"); |
4940 | const GLsizei len = (GLsizei) bswap_CARD32(pc + 8); |
4941 | |
4942 | ProgramStringARB((GLenum) bswap_ENUM(pc + 0), |
4943 | (GLenum) bswap_ENUM(pc + 4), |
4944 | len, (const GLvoid *) (pc + 12)); |
4945 | } |
4946 | |
4947 | void |
4948 | __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc) |
4949 | { |
4950 | PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB = |
4951 | __glGetProcAddress("glVertexAttrib1fvARB"); |
4952 | VertexAttrib1fvARB((GLuint) bswap_CARD32(pc + 0), |
4953 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
4954 | 1)); |
4955 | } |
4956 | |
4957 | void |
4958 | __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc) |
4959 | { |
4960 | PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB = |
4961 | __glGetProcAddress("glVertexAttrib2fvARB"); |
4962 | VertexAttrib2fvARB((GLuint) bswap_CARD32(pc + 0), |
4963 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
4964 | 2)); |
4965 | } |
4966 | |
4967 | void |
4968 | __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc) |
4969 | { |
4970 | PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB = |
4971 | __glGetProcAddress("glVertexAttrib3fvARB"); |
4972 | VertexAttrib3fvARB((GLuint) bswap_CARD32(pc + 0), |
4973 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
4974 | 3)); |
4975 | } |
4976 | |
4977 | void |
4978 | __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc) |
4979 | { |
4980 | PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB = |
4981 | __glGetProcAddress("glVertexAttrib4fvARB"); |
4982 | VertexAttrib4fvARB((GLuint) bswap_CARD32(pc + 0), |
4983 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
4984 | 4)); |
4985 | } |
4986 | |
4987 | void |
4988 | __glXDispSwap_BindFramebuffer(GLbyte * pc) |
4989 | { |
4990 | PFNGLBINDFRAMEBUFFERPROC BindFramebuffer = |
4991 | __glGetProcAddress("glBindFramebuffer"); |
4992 | BindFramebuffer((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4)); |
4993 | } |
4994 | |
4995 | void |
4996 | __glXDispSwap_BindRenderbuffer(GLbyte * pc) |
4997 | { |
4998 | PFNGLBINDRENDERBUFFERPROC BindRenderbuffer = |
4999 | __glGetProcAddress("glBindRenderbuffer"); |
5000 | BindRenderbuffer((GLenum) bswap_ENUM(pc + 0), |
5001 | (GLuint) bswap_CARD32(pc + 4)); |
5002 | } |
5003 | |
5004 | void |
5005 | __glXDispSwap_BlitFramebuffer(GLbyte * pc) |
5006 | { |
5007 | PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer = |
5008 | __glGetProcAddress("glBlitFramebuffer"); |
5009 | BlitFramebuffer((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4), |
5010 | (GLint) bswap_CARD32(pc + 8), (GLint) bswap_CARD32(pc + 12), |
5011 | (GLint) bswap_CARD32(pc + 16), |
5012 | (GLint) bswap_CARD32(pc + 20), |
5013 | (GLint) bswap_CARD32(pc + 24), |
5014 | (GLint) bswap_CARD32(pc + 28), |
5015 | (GLbitfield) bswap_CARD32(pc + 32), |
5016 | (GLenum) bswap_ENUM(pc + 36)); |
5017 | } |
5018 | |
5019 | int |
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 | |
5041 | void |
5042 | __glXDispSwap_DeleteFramebuffers(GLbyte * pc) |
5043 | { |
5044 | PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers = |
5045 | __glGetProcAddress("glDeleteFramebuffers"); |
5046 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 0); |
5047 | |
5048 | DeleteFramebuffers(n, |
5049 | (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), |
5050 | 0)); |
5051 | } |
5052 | |
5053 | void |
5054 | __glXDispSwap_DeleteRenderbuffers(GLbyte * pc) |
5055 | { |
5056 | PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers = |
5057 | __glGetProcAddress("glDeleteRenderbuffers"); |
5058 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 0); |
5059 | |
5060 | DeleteRenderbuffers(n, |
5061 | (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), |
5062 | 0)); |
5063 | } |
5064 | |
5065 | void |
5066 | __glXDispSwap_FramebufferRenderbuffer(GLbyte * pc) |
5067 | { |
5068 | PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer = |
5069 | __glGetProcAddress("glFramebufferRenderbuffer"); |
5070 | FramebufferRenderbuffer((GLenum) bswap_ENUM(pc + 0), |
5071 | (GLenum) bswap_ENUM(pc + 4), |
5072 | (GLenum) bswap_ENUM(pc + 8), |
5073 | (GLuint) bswap_CARD32(pc + 12)); |
5074 | } |
5075 | |
5076 | void |
5077 | __glXDispSwap_FramebufferTexture1D(GLbyte * pc) |
5078 | { |
5079 | PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D = |
5080 | __glGetProcAddress("glFramebufferTexture1D"); |
5081 | FramebufferTexture1D((GLenum) bswap_ENUM(pc + 0), |
5082 | (GLenum) bswap_ENUM(pc + 4), |
5083 | (GLenum) bswap_ENUM(pc + 8), |
5084 | (GLuint) bswap_CARD32(pc + 12), |
5085 | (GLint) bswap_CARD32(pc + 16)); |
5086 | } |
5087 | |
5088 | void |
5089 | __glXDispSwap_FramebufferTexture2D(GLbyte * pc) |
5090 | { |
5091 | PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D = |
5092 | __glGetProcAddress("glFramebufferTexture2D"); |
5093 | FramebufferTexture2D((GLenum) bswap_ENUM(pc + 0), |
5094 | (GLenum) bswap_ENUM(pc + 4), |
5095 | (GLenum) bswap_ENUM(pc + 8), |
5096 | (GLuint) bswap_CARD32(pc + 12), |
5097 | (GLint) bswap_CARD32(pc + 16)); |
5098 | } |
5099 | |
5100 | void |
5101 | __glXDispSwap_FramebufferTexture3D(GLbyte * pc) |
5102 | { |
5103 | PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D = |
5104 | __glGetProcAddress("glFramebufferTexture3D"); |
5105 | FramebufferTexture3D((GLenum) bswap_ENUM(pc + 0), |
5106 | (GLenum) bswap_ENUM(pc + 4), |
5107 | (GLenum) bswap_ENUM(pc + 8), |
5108 | (GLuint) bswap_CARD32(pc + 12), |
5109 | (GLint) bswap_CARD32(pc + 16), |
5110 | (GLint) bswap_CARD32(pc + 20)); |
5111 | } |
5112 | |
5113 | void |
5114 | __glXDispSwap_FramebufferTextureLayer(GLbyte * pc) |
5115 | { |
5116 | PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer = |
5117 | __glGetProcAddress("glFramebufferTextureLayer"); |
5118 | FramebufferTextureLayer((GLenum) bswap_ENUM(pc + 0), |
5119 | (GLenum) bswap_ENUM(pc + 4), |
5120 | (GLuint) bswap_CARD32(pc + 8), |
5121 | (GLint) bswap_CARD32(pc + 12), |
5122 | (GLint) bswap_CARD32(pc + 16)); |
5123 | } |
5124 | |
5125 | int |
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 | |
5156 | int |
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 | |
5187 | void |
5188 | __glXDispSwap_GenerateMipmap(GLbyte * pc) |
5189 | { |
5190 | PFNGLGENERATEMIPMAPPROC GenerateMipmap = |
5191 | __glGetProcAddress("glGenerateMipmap"); |
5192 | GenerateMipmap((GLenum) bswap_ENUM(pc + 0)); |
5193 | } |
5194 | |
5195 | int |
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 | |
5223 | int |
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 | |
5247 | int |
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 | |
5269 | int |
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 | |
5291 | void |
5292 | __glXDispSwap_RenderbufferStorage(GLbyte * pc) |
5293 | { |
5294 | PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage = |
5295 | __glGetProcAddress("glRenderbufferStorage"); |
5296 | RenderbufferStorage((GLenum) bswap_ENUM(pc + 0), |
5297 | (GLenum) bswap_ENUM(pc + 4), |
5298 | (GLsizei) bswap_CARD32(pc + 8), |
5299 | (GLsizei) bswap_CARD32(pc + 12)); |
5300 | } |
5301 | |
5302 | void |
5303 | __glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc) |
5304 | { |
5305 | PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample = |
5306 | __glGetProcAddress("glRenderbufferStorageMultisample"); |
5307 | RenderbufferStorageMultisample((GLenum) bswap_ENUM(pc + 0), |
5308 | (GLsizei) bswap_CARD32(pc + 4), |
5309 | (GLenum) bswap_ENUM(pc + 8), |
5310 | (GLsizei) bswap_CARD32(pc + 12), |
5311 | (GLsizei) bswap_CARD32(pc + 16)); |
5312 | } |
5313 | |
5314 | void |
5315 | __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc) |
5316 | { |
5317 | PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT = |
5318 | __glGetProcAddress("glSecondaryColor3fvEXT"); |
5319 | SecondaryColor3fvEXT((const GLfloat *) |
5320 | bswap_32_array((uint32_t *) (pc + 0), 3)); |
5321 | } |
5322 | |
5323 | void |
5324 | __glXDispSwap_FogCoordfvEXT(GLbyte * pc) |
5325 | { |
5326 | PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT = |
5327 | __glGetProcAddress("glFogCoordfvEXT"); |
5328 | FogCoordfvEXT((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1)); |
5329 | } |
5330 | |
5331 | void |
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 | |
5348 | void |
5349 | __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc) |
5350 | { |
5351 | PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV = |
5352 | __glGetProcAddress("glVertexAttrib1fvNV"); |
5353 | VertexAttrib1fvNV((GLuint) bswap_CARD32(pc + 0), |
5354 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
5355 | 1)); |
5356 | } |
5357 | |
5358 | void |
5359 | __glXDispSwap_VertexAttrib1svNV(GLbyte * pc) |
5360 | { |
5361 | PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV = |
5362 | __glGetProcAddress("glVertexAttrib1svNV"); |
5363 | VertexAttrib1svNV((GLuint) bswap_CARD32(pc + 0), |
5364 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
5365 | 1)); |
5366 | } |
5367 | |
5368 | void |
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 | |
5385 | void |
5386 | __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc) |
5387 | { |
5388 | PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV = |
5389 | __glGetProcAddress("glVertexAttrib2fvNV"); |
5390 | VertexAttrib2fvNV((GLuint) bswap_CARD32(pc + 0), |
5391 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
5392 | 2)); |
5393 | } |
5394 | |
5395 | void |
5396 | __glXDispSwap_VertexAttrib2svNV(GLbyte * pc) |
5397 | { |
5398 | PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV = |
5399 | __glGetProcAddress("glVertexAttrib2svNV"); |
5400 | VertexAttrib2svNV((GLuint) bswap_CARD32(pc + 0), |
5401 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
5402 | 2)); |
5403 | } |
5404 | |
5405 | void |
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 | |
5422 | void |
5423 | __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc) |
5424 | { |
5425 | PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV = |
5426 | __glGetProcAddress("glVertexAttrib3fvNV"); |
5427 | VertexAttrib3fvNV((GLuint) bswap_CARD32(pc + 0), |
5428 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
5429 | 3)); |
5430 | } |
5431 | |
5432 | void |
5433 | __glXDispSwap_VertexAttrib3svNV(GLbyte * pc) |
5434 | { |
5435 | PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV = |
5436 | __glGetProcAddress("glVertexAttrib3svNV"); |
5437 | VertexAttrib3svNV((GLuint) bswap_CARD32(pc + 0), |
5438 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
5439 | 3)); |
5440 | } |
5441 | |
5442 | void |
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 | |
5459 | void |
5460 | __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc) |
5461 | { |
5462 | PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV = |
5463 | __glGetProcAddress("glVertexAttrib4fvNV"); |
5464 | VertexAttrib4fvNV((GLuint) bswap_CARD32(pc + 0), |
5465 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4), |
5466 | 4)); |
5467 | } |
5468 | |
5469 | void |
5470 | __glXDispSwap_VertexAttrib4svNV(GLbyte * pc) |
5471 | { |
5472 | PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV = |
5473 | __glGetProcAddress("glVertexAttrib4svNV"); |
5474 | VertexAttrib4svNV((GLuint) bswap_CARD32(pc + 0), |
5475 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), |
5476 | 4)); |
5477 | } |
5478 | |
5479 | void |
5480 | __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc) |
5481 | { |
5482 | PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV = |
5483 | __glGetProcAddress("glVertexAttrib4ubvNV"); |
5484 | VertexAttrib4ubvNV((GLuint) bswap_CARD32(pc + 0), |
5485 | (const GLubyte *) (pc + 4)); |
5486 | } |
5487 | |
5488 | void |
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 | |
5510 | void |
5511 | __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc) |
5512 | { |
5513 | PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV = |
5514 | __glGetProcAddress("glVertexAttribs1fvNV"); |
5515 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5516 | |
5517 | VertexAttribs1fvNV((GLuint) bswap_CARD32(pc + 0), |
5518 | n, |
5519 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
5520 | 0)); |
5521 | } |
5522 | |
5523 | void |
5524 | __glXDispSwap_VertexAttribs1svNV(GLbyte * pc) |
5525 | { |
5526 | PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV = |
5527 | __glGetProcAddress("glVertexAttribs1svNV"); |
5528 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5529 | |
5530 | VertexAttribs1svNV((GLuint) bswap_CARD32(pc + 0), |
5531 | n, |
5532 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 8), |
5533 | 0)); |
5534 | } |
5535 | |
5536 | void |
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 | |
5558 | void |
5559 | __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc) |
5560 | { |
5561 | PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV = |
5562 | __glGetProcAddress("glVertexAttribs2fvNV"); |
5563 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5564 | |
5565 | VertexAttribs2fvNV((GLuint) bswap_CARD32(pc + 0), |
5566 | n, |
5567 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
5568 | 0)); |
5569 | } |
5570 | |
5571 | void |
5572 | __glXDispSwap_VertexAttribs2svNV(GLbyte * pc) |
5573 | { |
5574 | PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV = |
5575 | __glGetProcAddress("glVertexAttribs2svNV"); |
5576 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5577 | |
5578 | VertexAttribs2svNV((GLuint) bswap_CARD32(pc + 0), |
5579 | n, |
5580 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 8), |
5581 | 0)); |
5582 | } |
5583 | |
5584 | void |
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 | |
5606 | void |
5607 | __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc) |
5608 | { |
5609 | PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV = |
5610 | __glGetProcAddress("glVertexAttribs3fvNV"); |
5611 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5612 | |
5613 | VertexAttribs3fvNV((GLuint) bswap_CARD32(pc + 0), |
5614 | n, |
5615 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
5616 | 0)); |
5617 | } |
5618 | |
5619 | void |
5620 | __glXDispSwap_VertexAttribs3svNV(GLbyte * pc) |
5621 | { |
5622 | PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV = |
5623 | __glGetProcAddress("glVertexAttribs3svNV"); |
5624 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5625 | |
5626 | VertexAttribs3svNV((GLuint) bswap_CARD32(pc + 0), |
5627 | n, |
5628 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 8), |
5629 | 0)); |
5630 | } |
5631 | |
5632 | void |
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 | |
5654 | void |
5655 | __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc) |
5656 | { |
5657 | PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV = |
5658 | __glGetProcAddress("glVertexAttribs4fvNV"); |
5659 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5660 | |
5661 | VertexAttribs4fvNV((GLuint) bswap_CARD32(pc + 0), |
5662 | n, |
5663 | (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), |
5664 | 0)); |
5665 | } |
5666 | |
5667 | void |
5668 | __glXDispSwap_VertexAttribs4svNV(GLbyte * pc) |
5669 | { |
5670 | PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV = |
5671 | __glGetProcAddress("glVertexAttribs4svNV"); |
5672 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5673 | |
5674 | VertexAttribs4svNV((GLuint) bswap_CARD32(pc + 0), |
5675 | n, |
5676 | (const GLshort *) bswap_16_array((uint16_t *) (pc + 8), |
5677 | 0)); |
5678 | } |
5679 | |
5680 | void |
5681 | __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc) |
5682 | { |
5683 | PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV = |
5684 | __glGetProcAddress("glVertexAttribs4ubvNV"); |
5685 | const GLsizei n = (GLsizei) bswap_CARD32(pc + 4); |
5686 | |
5687 | VertexAttribs4ubvNV((GLuint) bswap_CARD32(pc + 0), |
5688 | n, (const GLubyte *) (pc + 8)); |
5689 | } |
5690 | |
5691 | void |
5692 | __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc) |
5693 | { |
5694 | PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT = |
5695 | __glGetProcAddress("glActiveStencilFaceEXT"); |
5696 | ActiveStencilFaceEXT((GLenum) bswap_ENUM(pc + 0)); |
5697 | } |