projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
glapi: regenerated files for GL_ARB_copy_buffer
[mesa.git] / src / glx / x11 / indirect.c
1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
2
3 /*
4 * (C) Copyright IBM Corporation 2004, 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
29 #include <GL/gl.h>
30 #include "indirect.h"
31 #include "glxclient.h"
32 #include "indirect_size.h"
33 #include "dispatch.h"
34 #include "glapi.h"
35 #include "glthread.h"
36 #include <GL/glxproto.h>
37 #ifdef USE_XCB
38 #include <X11/Xlib-xcb.h>
39 #include <xcb/xcb.h>
40 #include <xcb/glx.h>
41 #endif /* USE_XCB */
42
43 #define __GLX_PAD(n) (((n) + 3) & ~3)
44
45 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
46 # define FASTCALL __attribute__((fastcall))
47 # else
48 # define FASTCALL
49 # endif
50 # if defined(__GNUC__)
51 # define NOINLINE __attribute__((noinline))
52 # else
53 # define NOINLINE
54 # endif
55
56 #if !defined __GNUC__ || __GNUC__ < 3
57 # define __builtin_expect(x, y) x
58 #endif
59
60 /* If the size and opcode values are known at compile-time, this will, on
61 * x86 at least, emit them with a single instruction.
62 */
63 #define emit_header(dest, op, size) \
64 do { union { short s[2]; int i; } temp; \
65 temp.s[0] = (size); temp.s[1] = (op); \
66 *((int *)(dest)) = temp.i; } while(0)
67
68 NOINLINE CARD32
69 __glXReadReply(Display * dpy, size_t size, void *dest,
70 GLboolean reply_is_always_array)
71 {
72 xGLXSingleReply reply;
73
74 (void) _XReply(dpy, (xReply *) & reply, 0, False);
75 if (size != 0) {
76 if ((reply.length > 0) || reply_is_always_array) {
77 const GLint bytes = (reply_is_always_array)
78 ? (4 * reply.length) : (reply.size * size);
79 const GLint extra = 4 - (bytes & 3);
80
81 _XRead(dpy, dest, bytes);
82 if (extra < 4) {
83 _XEatData(dpy, extra);
84 }
85 } else {
86 (void) memcpy(dest, &(reply.pad3), size);
87 }
88 }
89
90 return reply.retval;
91 }
92
93 NOINLINE void
94 __glXReadPixelReply(Display * dpy, __GLXcontext * gc, unsigned max_dim,
95 GLint width, GLint height, GLint depth, GLenum format,
96 GLenum type, void *dest, GLboolean dimensions_in_reply)
97 {
98 xGLXSingleReply reply;
99 GLint size;
100
101 (void) _XReply(dpy, (xReply *) & reply, 0, False);
102
103 if (dimensions_in_reply) {
104 width = reply.pad3;
105 height = reply.pad4;
106 depth = reply.pad5;
107
108 if ((height == 0) || (max_dim < 2)) {
109 height = 1;
110 }
111 if ((depth == 0) || (max_dim < 3)) {
112 depth = 1;
113 }
114 }
115
116 size = reply.length * 4;
117 if (size != 0) {
118 void *buf = Xmalloc(size);
119
120 if (buf == NULL) {
121 _XEatData(dpy, size);
122 __glXSetError(gc, GL_OUT_OF_MEMORY);
123 } else {
124 const GLint extra = 4 - (size & 3);
125
126 _XRead(dpy, buf, size);
127 if (extra < 4) {
128 _XEatData(dpy, extra);
129 }
130
131 __glEmptyImage(gc, 3, width, height, depth, format, type,
132 buf, dest);
133 Xfree(buf);
134 }
135 }
136 }
137
138 #define X_GLXSingle 0
139
140 NOINLINE FASTCALL GLubyte *
141 __glXSetupSingleRequest(__GLXcontext * gc, GLint sop, GLint cmdlen)
142 {
143 xGLXSingleReq *req;
144 Display *const dpy = gc->currentDpy;
145
146 (void) __glXFlushRenderBuffer(gc, gc->pc);
147 LockDisplay(dpy);
148 GetReqExtra(GLXSingle, cmdlen, req);
149 req->reqType = gc->majorOpcode;
150 req->contextTag = gc->currentContextTag;
151 req->glxCode = sop;
152 return (GLubyte *) (req) + sz_xGLXSingleReq;
153 }
154
155 NOINLINE FASTCALL GLubyte *
156 __glXSetupVendorRequest(__GLXcontext * gc, GLint code, GLint vop,
157 GLint cmdlen)
158 {
159 xGLXVendorPrivateReq *req;
160 Display *const dpy = gc->currentDpy;
161
162 (void) __glXFlushRenderBuffer(gc, gc->pc);
163 LockDisplay(dpy);
164 GetReqExtra(GLXVendorPrivate, cmdlen, req);
165 req->reqType = gc->majorOpcode;
166 req->glxCode = code;
167 req->vendorCode = vop;
168 req->contextTag = gc->currentContextTag;
169 return (GLubyte *) (req) + sz_xGLXVendorPrivateReq;
170 }
171
172 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
173
174 #define zero (__glXDefaultPixelStore+0)
175 #define one (__glXDefaultPixelStore+8)
176 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
177 #define default_pixel_store_1D_size 20
178 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
179 #define default_pixel_store_2D_size 20
180 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
181 #define default_pixel_store_3D_size 36
182 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
183 #define default_pixel_store_4D_size 36
184
185 static FASTCALL NOINLINE void
186 generic_3_byte(GLint rop, const void *ptr)
187 {
188 __GLXcontext *const gc = __glXGetCurrentContext();
189 const GLuint cmdlen = 8;
190
191 emit_header(gc->pc, rop, cmdlen);
192 (void) memcpy((void *) (gc->pc + 4), ptr, 4);
193 gc->pc += cmdlen;
194 if (__builtin_expect(gc->pc > gc->limit, 0)) {
195 (void) __glXFlushRenderBuffer(gc, gc->pc);
196 }
197 }
198
199 static FASTCALL NOINLINE void
200 generic_4_byte(GLint rop, const void *ptr)
201 {
202 __GLXcontext *const gc = __glXGetCurrentContext();
203 const GLuint cmdlen = 8;
204
205 emit_header(gc->pc, rop, cmdlen);
206 (void) memcpy((void *) (gc->pc + 4), ptr, 4);
207 gc->pc += cmdlen;
208 if (__builtin_expect(gc->pc > gc->limit, 0)) {
209 (void) __glXFlushRenderBuffer(gc, gc->pc);
210 }
211 }
212
213 static FASTCALL NOINLINE void
214 generic_6_byte(GLint rop, const void *ptr)
215 {
216 __GLXcontext *const gc = __glXGetCurrentContext();
217 const GLuint cmdlen = 12;
218
219 emit_header(gc->pc, rop, cmdlen);
220 (void) memcpy((void *) (gc->pc + 4), ptr, 8);
221 gc->pc += cmdlen;
222 if (__builtin_expect(gc->pc > gc->limit, 0)) {
223 (void) __glXFlushRenderBuffer(gc, gc->pc);
224 }
225 }
226
227 static FASTCALL NOINLINE void
228 generic_8_byte(GLint rop, const void *ptr)
229 {
230 __GLXcontext *const gc = __glXGetCurrentContext();
231 const GLuint cmdlen = 12;
232
233 emit_header(gc->pc, rop, cmdlen);
234 (void) memcpy((void *) (gc->pc + 4), ptr, 8);
235 gc->pc += cmdlen;
236 if (__builtin_expect(gc->pc > gc->limit, 0)) {
237 (void) __glXFlushRenderBuffer(gc, gc->pc);
238 }
239 }
240
241 static FASTCALL NOINLINE void
242 generic_12_byte(GLint rop, const void *ptr)
243 {
244 __GLXcontext *const gc = __glXGetCurrentContext();
245 const GLuint cmdlen = 16;
246
247 emit_header(gc->pc, rop, cmdlen);
248 (void) memcpy((void *) (gc->pc + 4), ptr, 12);
249 gc->pc += cmdlen;
250 if (__builtin_expect(gc->pc > gc->limit, 0)) {
251 (void) __glXFlushRenderBuffer(gc, gc->pc);
252 }
253 }
254
255 static FASTCALL NOINLINE void
256 generic_16_byte(GLint rop, const void *ptr)
257 {
258 __GLXcontext *const gc = __glXGetCurrentContext();
259 const GLuint cmdlen = 20;
260
261 emit_header(gc->pc, rop, cmdlen);
262 (void) memcpy((void *) (gc->pc + 4), ptr, 16);
263 gc->pc += cmdlen;
264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
265 (void) __glXFlushRenderBuffer(gc, gc->pc);
266 }
267 }
268
269 static FASTCALL NOINLINE void
270 generic_24_byte(GLint rop, const void *ptr)
271 {
272 __GLXcontext *const gc = __glXGetCurrentContext();
273 const GLuint cmdlen = 28;
274
275 emit_header(gc->pc, rop, cmdlen);
276 (void) memcpy((void *) (gc->pc + 4), ptr, 24);
277 gc->pc += cmdlen;
278 if (__builtin_expect(gc->pc > gc->limit, 0)) {
279 (void) __glXFlushRenderBuffer(gc, gc->pc);
280 }
281 }
282
283 static FASTCALL NOINLINE void
284 generic_32_byte(GLint rop, const void *ptr)
285 {
286 __GLXcontext *const gc = __glXGetCurrentContext();
287 const GLuint cmdlen = 36;
288
289 emit_header(gc->pc, rop, cmdlen);
290 (void) memcpy((void *) (gc->pc + 4), ptr, 32);
291 gc->pc += cmdlen;
292 if (__builtin_expect(gc->pc > gc->limit, 0)) {
293 (void) __glXFlushRenderBuffer(gc, gc->pc);
294 }
295 }
296
297 #define X_GLsop_NewList 101
298 void
299 __indirect_glNewList(GLuint list, GLenum mode)
300 {
301 __GLXcontext *const gc = __glXGetCurrentContext();
302 Display *const dpy = gc->currentDpy;
303 #ifndef USE_XCB
304 const GLuint cmdlen = 8;
305 #endif
306 if (__builtin_expect(dpy != NULL, 1)) {
307 #ifdef USE_XCB
308 xcb_connection_t *c = XGetXCBConnection(dpy);
309 (void) __glXFlushRenderBuffer(gc, gc->pc);
310 xcb_glx_new_list(c, gc->currentContextTag, list, mode);
311 #else
312 GLubyte const *pc =
313 __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
314 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
315 (void) memcpy((void *) (pc + 4), (void *) (&mode), 4);
316 UnlockDisplay(dpy);
317 SyncHandle();
318 #endif /* USE_XCB */
319 }
320 return;
321 }
322
323 #define X_GLsop_EndList 102
324 void
325 __indirect_glEndList(void)
326 {
327 __GLXcontext *const gc = __glXGetCurrentContext();
328 Display *const dpy = gc->currentDpy;
329 #ifndef USE_XCB
330 const GLuint cmdlen = 0;
331 #endif
332 if (__builtin_expect(dpy != NULL, 1)) {
333 #ifdef USE_XCB
334 xcb_connection_t *c = XGetXCBConnection(dpy);
335 (void) __glXFlushRenderBuffer(gc, gc->pc);
336 xcb_glx_end_list(c, gc->currentContextTag);
337 #else
338 (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
339 UnlockDisplay(dpy);
340 SyncHandle();
341 #endif /* USE_XCB */
342 }
343 return;
344 }
345
346 #define X_GLrop_CallList 1
347 void
348 __indirect_glCallList(GLuint list)
349 {
350 __GLXcontext *const gc = __glXGetCurrentContext();
351 const GLuint cmdlen = 8;
352 emit_header(gc->pc, X_GLrop_CallList, cmdlen);
353 (void) memcpy((void *) (gc->pc + 4), (void *) (&list), 4);
354 gc->pc += cmdlen;
355 if (__builtin_expect(gc->pc > gc->limit, 0)) {
356 (void) __glXFlushRenderBuffer(gc, gc->pc);
357 }
358 }
359
360 #define X_GLrop_CallLists 2
361 void
362 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
363 {
364 __GLXcontext *const gc = __glXGetCurrentContext();
365 const GLuint compsize = __glCallLists_size(type);
366 const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
367 if (n < 0) {
368 __glXSetError(gc, GL_INVALID_VALUE);
369 return;
370 }
371 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
372 if (cmdlen <= gc->maxSmallRenderCommandSize) {
373 if ((gc->pc + cmdlen) > gc->bufEnd) {
374 (void) __glXFlushRenderBuffer(gc, gc->pc);
375 }
376 emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
377 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
378 (void) memcpy((void *) (gc->pc + 8), (void *) (&type), 4);
379 (void) memcpy((void *) (gc->pc + 12), (void *) (lists),
380 (compsize * n));
381 gc->pc += cmdlen;
382 if (__builtin_expect(gc->pc > gc->limit, 0)) {
383 (void) __glXFlushRenderBuffer(gc, gc->pc);
384 }
385 } else {
386 const GLint op = X_GLrop_CallLists;
387 const GLuint cmdlenLarge = cmdlen + 4;
388 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
389 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
390 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
391 (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
392 (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
393 __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
394 }
395 }
396 }
397
398 #define X_GLsop_DeleteLists 103
399 void
400 __indirect_glDeleteLists(GLuint list, GLsizei range)
401 {
402 __GLXcontext *const gc = __glXGetCurrentContext();
403 Display *const dpy = gc->currentDpy;
404 #ifndef USE_XCB
405 const GLuint cmdlen = 8;
406 #endif
407 if (__builtin_expect(dpy != NULL, 1)) {
408 #ifdef USE_XCB
409 xcb_connection_t *c = XGetXCBConnection(dpy);
410 (void) __glXFlushRenderBuffer(gc, gc->pc);
411 xcb_glx_delete_lists(c, gc->currentContextTag, list, range);
412 #else
413 GLubyte const *pc =
414 __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
415 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
416 (void) memcpy((void *) (pc + 4), (void *) (&range), 4);
417 UnlockDisplay(dpy);
418 SyncHandle();
419 #endif /* USE_XCB */
420 }
421 return;
422 }
423
424 #define X_GLsop_GenLists 104
425 GLuint
426 __indirect_glGenLists(GLsizei range)
427 {
428 __GLXcontext *const gc = __glXGetCurrentContext();
429 Display *const dpy = gc->currentDpy;
430 GLuint retval = (GLuint) 0;
431 #ifndef USE_XCB
432 const GLuint cmdlen = 4;
433 #endif
434 if (__builtin_expect(dpy != NULL, 1)) {
435 #ifdef USE_XCB
436 xcb_connection_t *c = XGetXCBConnection(dpy);
437 (void) __glXFlushRenderBuffer(gc, gc->pc);
438 xcb_glx_gen_lists_reply_t *reply =
439 xcb_glx_gen_lists_reply(c,
440 xcb_glx_gen_lists(c,
441 gc->currentContextTag,
442 range), NULL);
443 retval = reply->ret_val;
444 free(reply);
445 #else
446 GLubyte const *pc =
447 __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
448 (void) memcpy((void *) (pc + 0), (void *) (&range), 4);
449 retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
450 UnlockDisplay(dpy);
451 SyncHandle();
452 #endif /* USE_XCB */
453 }
454 return retval;
455 }
456
457 #define X_GLrop_ListBase 3
458 void
459 __indirect_glListBase(GLuint base)
460 {
461 __GLXcontext *const gc = __glXGetCurrentContext();
462 const GLuint cmdlen = 8;
463 emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
464 (void) memcpy((void *) (gc->pc + 4), (void *) (&base), 4);
465 gc->pc += cmdlen;
466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
467 (void) __glXFlushRenderBuffer(gc, gc->pc);
468 }
469 }
470
471 #define X_GLrop_Begin 4
472 void
473 __indirect_glBegin(GLenum mode)
474 {
475 __GLXcontext *const gc = __glXGetCurrentContext();
476 const GLuint cmdlen = 8;
477 emit_header(gc->pc, X_GLrop_Begin, cmdlen);
478 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
479 gc->pc += cmdlen;
480 if (__builtin_expect(gc->pc > gc->limit, 0)) {
481 (void) __glXFlushRenderBuffer(gc, gc->pc);
482 }
483 }
484
485 #define X_GLrop_Bitmap 5
486 void
487 __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig,
488 GLfloat yorig, GLfloat xmove, GLfloat ymove,
489 const GLubyte *bitmap)
490 {
491 __GLXcontext *const gc = __glXGetCurrentContext();
492 const GLuint compsize =
493 (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX,
494 GL_BITMAP, 0) : 0;
495 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
496 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
497 if (cmdlen <= gc->maxSmallRenderCommandSize) {
498 if ((gc->pc + cmdlen) > gc->bufEnd) {
499 (void) __glXFlushRenderBuffer(gc, gc->pc);
500 }
501 emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
502 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
503 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
504 (void) memcpy((void *) (gc->pc + 32), (void *) (&xorig), 4);
505 (void) memcpy((void *) (gc->pc + 36), (void *) (&yorig), 4);
506 (void) memcpy((void *) (gc->pc + 40), (void *) (&xmove), 4);
507 (void) memcpy((void *) (gc->pc + 44), (void *) (&ymove), 4);
508 if (compsize > 0) {
509 (*gc->fillImage) (gc, 2, width, height, 1, GL_COLOR_INDEX,
510 GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
511 } else {
512 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
513 default_pixel_store_2D_size);
514 }
515 gc->pc += cmdlen;
516 if (gc->pc > gc->limit) {
517 (void) __glXFlushRenderBuffer(gc, gc->pc);
518 }
519 } else {
520 const GLint op = X_GLrop_Bitmap;
521 const GLuint cmdlenLarge = cmdlen + 4;
522 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
523 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
524 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
525 (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
526 (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
527 (void) memcpy((void *) (pc + 36), (void *) (&xorig), 4);
528 (void) memcpy((void *) (pc + 40), (void *) (&yorig), 4);
529 (void) memcpy((void *) (pc + 44), (void *) (&xmove), 4);
530 (void) memcpy((void *) (pc + 48), (void *) (&ymove), 4);
531 __glXSendLargeImage(gc, compsize, 2, width, height, 1,
532 GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52,
533 pc + 8);
534 }
535 }
536 }
537
538 #define X_GLrop_Color3bv 6
539 void
540 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
541 {
542 __GLXcontext *const gc = __glXGetCurrentContext();
543 const GLuint cmdlen = 8;
544 emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
545 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
546 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
547 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
548 gc->pc += cmdlen;
549 if (__builtin_expect(gc->pc > gc->limit, 0)) {
550 (void) __glXFlushRenderBuffer(gc, gc->pc);
551 }
552 }
553
554 #define X_GLrop_Color3bv 6
555 void
556 __indirect_glColor3bv(const GLbyte *v)
557 {
558 generic_3_byte(X_GLrop_Color3bv, v);
559 }
560
561 #define X_GLrop_Color3dv 7
562 void
563 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
564 {
565 __GLXcontext *const gc = __glXGetCurrentContext();
566 const GLuint cmdlen = 28;
567 emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
568 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
569 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
570 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
571 gc->pc += cmdlen;
572 if (__builtin_expect(gc->pc > gc->limit, 0)) {
573 (void) __glXFlushRenderBuffer(gc, gc->pc);
574 }
575 }
576
577 #define X_GLrop_Color3dv 7
578 void
579 __indirect_glColor3dv(const GLdouble * v)
580 {
581 generic_24_byte(X_GLrop_Color3dv, v);
582 }
583
584 #define X_GLrop_Color3fv 8
585 void
586 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
587 {
588 __GLXcontext *const gc = __glXGetCurrentContext();
589 const GLuint cmdlen = 16;
590 emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
591 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
592 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
593 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
594 gc->pc += cmdlen;
595 if (__builtin_expect(gc->pc > gc->limit, 0)) {
596 (void) __glXFlushRenderBuffer(gc, gc->pc);
597 }
598 }
599
600 #define X_GLrop_Color3fv 8
601 void
602 __indirect_glColor3fv(const GLfloat * v)
603 {
604 generic_12_byte(X_GLrop_Color3fv, v);
605 }
606
607 #define X_GLrop_Color3iv 9
608 void
609 __indirect_glColor3i(GLint red, GLint green, GLint blue)
610 {
611 __GLXcontext *const gc = __glXGetCurrentContext();
612 const GLuint cmdlen = 16;
613 emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
614 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
615 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
616 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
617 gc->pc += cmdlen;
618 if (__builtin_expect(gc->pc > gc->limit, 0)) {
619 (void) __glXFlushRenderBuffer(gc, gc->pc);
620 }
621 }
622
623 #define X_GLrop_Color3iv 9
624 void
625 __indirect_glColor3iv(const GLint * v)
626 {
627 generic_12_byte(X_GLrop_Color3iv, v);
628 }
629
630 #define X_GLrop_Color3sv 10
631 void
632 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
633 {
634 __GLXcontext *const gc = __glXGetCurrentContext();
635 const GLuint cmdlen = 12;
636 emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
637 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
638 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
639 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
640 gc->pc += cmdlen;
641 if (__builtin_expect(gc->pc > gc->limit, 0)) {
642 (void) __glXFlushRenderBuffer(gc, gc->pc);
643 }
644 }
645
646 #define X_GLrop_Color3sv 10
647 void
648 __indirect_glColor3sv(const GLshort * v)
649 {
650 generic_6_byte(X_GLrop_Color3sv, v);
651 }
652
653 #define X_GLrop_Color3ubv 11
654 void
655 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
656 {
657 __GLXcontext *const gc = __glXGetCurrentContext();
658 const GLuint cmdlen = 8;
659 emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
660 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
661 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
662 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
663 gc->pc += cmdlen;
664 if (__builtin_expect(gc->pc > gc->limit, 0)) {
665 (void) __glXFlushRenderBuffer(gc, gc->pc);
666 }
667 }
668
669 #define X_GLrop_Color3ubv 11
670 void
671 __indirect_glColor3ubv(const GLubyte *v)
672 {
673 generic_3_byte(X_GLrop_Color3ubv, v);
674 }
675
676 #define X_GLrop_Color3uiv 12
677 void
678 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
679 {
680 __GLXcontext *const gc = __glXGetCurrentContext();
681 const GLuint cmdlen = 16;
682 emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
683 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
684 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
685 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
686 gc->pc += cmdlen;
687 if (__builtin_expect(gc->pc > gc->limit, 0)) {
688 (void) __glXFlushRenderBuffer(gc, gc->pc);
689 }
690 }
691
692 #define X_GLrop_Color3uiv 12
693 void
694 __indirect_glColor3uiv(const GLuint * v)
695 {
696 generic_12_byte(X_GLrop_Color3uiv, v);
697 }
698
699 #define X_GLrop_Color3usv 13
700 void
701 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
702 {
703 __GLXcontext *const gc = __glXGetCurrentContext();
704 const GLuint cmdlen = 12;
705 emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
706 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
707 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
708 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
709 gc->pc += cmdlen;
710 if (__builtin_expect(gc->pc > gc->limit, 0)) {
711 (void) __glXFlushRenderBuffer(gc, gc->pc);
712 }
713 }
714
715 #define X_GLrop_Color3usv 13
716 void
717 __indirect_glColor3usv(const GLushort * v)
718 {
719 generic_6_byte(X_GLrop_Color3usv, v);
720 }
721
722 #define X_GLrop_Color4bv 14
723 void
724 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
725 {
726 __GLXcontext *const gc = __glXGetCurrentContext();
727 const GLuint cmdlen = 8;
728 emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
729 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
730 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
731 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
732 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
733 gc->pc += cmdlen;
734 if (__builtin_expect(gc->pc > gc->limit, 0)) {
735 (void) __glXFlushRenderBuffer(gc, gc->pc);
736 }
737 }
738
739 #define X_GLrop_Color4bv 14
740 void
741 __indirect_glColor4bv(const GLbyte *v)
742 {
743 generic_4_byte(X_GLrop_Color4bv, v);
744 }
745
746 #define X_GLrop_Color4dv 15
747 void
748 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue,
749 GLdouble alpha)
750 {
751 __GLXcontext *const gc = __glXGetCurrentContext();
752 const GLuint cmdlen = 36;
753 emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
754 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
755 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
756 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
757 (void) memcpy((void *) (gc->pc + 28), (void *) (&alpha), 8);
758 gc->pc += cmdlen;
759 if (__builtin_expect(gc->pc > gc->limit, 0)) {
760 (void) __glXFlushRenderBuffer(gc, gc->pc);
761 }
762 }
763
764 #define X_GLrop_Color4dv 15
765 void
766 __indirect_glColor4dv(const GLdouble * v)
767 {
768 generic_32_byte(X_GLrop_Color4dv, v);
769 }
770
771 #define X_GLrop_Color4fv 16
772 void
773 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
774 {
775 __GLXcontext *const gc = __glXGetCurrentContext();
776 const GLuint cmdlen = 20;
777 emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
778 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
779 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
780 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
781 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
782 gc->pc += cmdlen;
783 if (__builtin_expect(gc->pc > gc->limit, 0)) {
784 (void) __glXFlushRenderBuffer(gc, gc->pc);
785 }
786 }
787
788 #define X_GLrop_Color4fv 16
789 void
790 __indirect_glColor4fv(const GLfloat * v)
791 {
792 generic_16_byte(X_GLrop_Color4fv, v);
793 }
794
795 #define X_GLrop_Color4iv 17
796 void
797 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
798 {
799 __GLXcontext *const gc = __glXGetCurrentContext();
800 const GLuint cmdlen = 20;
801 emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
802 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
803 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
804 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
805 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
806 gc->pc += cmdlen;
807 if (__builtin_expect(gc->pc > gc->limit, 0)) {
808 (void) __glXFlushRenderBuffer(gc, gc->pc);
809 }
810 }
811
812 #define X_GLrop_Color4iv 17
813 void
814 __indirect_glColor4iv(const GLint * v)
815 {
816 generic_16_byte(X_GLrop_Color4iv, v);
817 }
818
819 #define X_GLrop_Color4sv 18
820 void
821 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
822 {
823 __GLXcontext *const gc = __glXGetCurrentContext();
824 const GLuint cmdlen = 12;
825 emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
826 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
827 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
828 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
829 (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
830 gc->pc += cmdlen;
831 if (__builtin_expect(gc->pc > gc->limit, 0)) {
832 (void) __glXFlushRenderBuffer(gc, gc->pc);
833 }
834 }
835
836 #define X_GLrop_Color4sv 18
837 void
838 __indirect_glColor4sv(const GLshort * v)
839 {
840 generic_8_byte(X_GLrop_Color4sv, v);
841 }
842
843 #define X_GLrop_Color4ubv 19
844 void
845 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
846 {
847 __GLXcontext *const gc = __glXGetCurrentContext();
848 const GLuint cmdlen = 8;
849 emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
850 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
851 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
852 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
853 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
854 gc->pc += cmdlen;
855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
856 (void) __glXFlushRenderBuffer(gc, gc->pc);
857 }
858 }
859
860 #define X_GLrop_Color4ubv 19
861 void
862 __indirect_glColor4ubv(const GLubyte *v)
863 {
864 generic_4_byte(X_GLrop_Color4ubv, v);
865 }
866
867 #define X_GLrop_Color4uiv 20
868 void
869 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
870 {
871 __GLXcontext *const gc = __glXGetCurrentContext();
872 const GLuint cmdlen = 20;
873 emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
874 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
875 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
876 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
877 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
878 gc->pc += cmdlen;
879 if (__builtin_expect(gc->pc > gc->limit, 0)) {
880 (void) __glXFlushRenderBuffer(gc, gc->pc);
881 }
882 }
883
884 #define X_GLrop_Color4uiv 20
885 void
886 __indirect_glColor4uiv(const GLuint * v)
887 {
888 generic_16_byte(X_GLrop_Color4uiv, v);
889 }
890
891 #define X_GLrop_Color4usv 21
892 void
893 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue,
894 GLushort alpha)
895 {
896 __GLXcontext *const gc = __glXGetCurrentContext();
897 const GLuint cmdlen = 12;
898 emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
899 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
900 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
901 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
902 (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
903 gc->pc += cmdlen;
904 if (__builtin_expect(gc->pc > gc->limit, 0)) {
905 (void) __glXFlushRenderBuffer(gc, gc->pc);
906 }
907 }
908
909 #define X_GLrop_Color4usv 21
910 void
911 __indirect_glColor4usv(const GLushort * v)
912 {
913 generic_8_byte(X_GLrop_Color4usv, v);
914 }
915
916 #define X_GLrop_EdgeFlagv 22
917 void
918 __indirect_glEdgeFlag(GLboolean flag)
919 {
920 __GLXcontext *const gc = __glXGetCurrentContext();
921 const GLuint cmdlen = 8;
922 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
923 (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
924 gc->pc += cmdlen;
925 if (__builtin_expect(gc->pc > gc->limit, 0)) {
926 (void) __glXFlushRenderBuffer(gc, gc->pc);
927 }
928 }
929
930 #define X_GLrop_EdgeFlagv 22
931 void
932 __indirect_glEdgeFlagv(const GLboolean * flag)
933 {
934 __GLXcontext *const gc = __glXGetCurrentContext();
935 const GLuint cmdlen = 8;
936 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
937 (void) memcpy((void *) (gc->pc + 4), (void *) (flag), 1);
938 gc->pc += cmdlen;
939 if (__builtin_expect(gc->pc > gc->limit, 0)) {
940 (void) __glXFlushRenderBuffer(gc, gc->pc);
941 }
942 }
943
944 #define X_GLrop_End 23
945 void
946 __indirect_glEnd(void)
947 {
948 __GLXcontext *const gc = __glXGetCurrentContext();
949 const GLuint cmdlen = 4;
950 emit_header(gc->pc, X_GLrop_End, cmdlen);
951 gc->pc += cmdlen;
952 if (__builtin_expect(gc->pc > gc->limit, 0)) {
953 (void) __glXFlushRenderBuffer(gc, gc->pc);
954 }
955 }
956
957 #define X_GLrop_Indexdv 24
958 void
959 __indirect_glIndexd(GLdouble c)
960 {
961 __GLXcontext *const gc = __glXGetCurrentContext();
962 const GLuint cmdlen = 12;
963 emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
964 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 8);
965 gc->pc += cmdlen;
966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
967 (void) __glXFlushRenderBuffer(gc, gc->pc);
968 }
969 }
970
971 #define X_GLrop_Indexdv 24
972 void
973 __indirect_glIndexdv(const GLdouble * c)
974 {
975 generic_8_byte(X_GLrop_Indexdv, c);
976 }
977
978 #define X_GLrop_Indexfv 25
979 void
980 __indirect_glIndexf(GLfloat c)
981 {
982 __GLXcontext *const gc = __glXGetCurrentContext();
983 const GLuint cmdlen = 8;
984 emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
985 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
986 gc->pc += cmdlen;
987 if (__builtin_expect(gc->pc > gc->limit, 0)) {
988 (void) __glXFlushRenderBuffer(gc, gc->pc);
989 }
990 }
991
992 #define X_GLrop_Indexfv 25
993 void
994 __indirect_glIndexfv(const GLfloat * c)
995 {
996 generic_4_byte(X_GLrop_Indexfv, c);
997 }
998
999 #define X_GLrop_Indexiv 26
1000 void
1001 __indirect_glIndexi(GLint c)
1002 {
1003 __GLXcontext *const gc = __glXGetCurrentContext();
1004 const GLuint cmdlen = 8;
1005 emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
1006 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
1007 gc->pc += cmdlen;
1008 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1009 (void) __glXFlushRenderBuffer(gc, gc->pc);
1010 }
1011 }
1012
1013 #define X_GLrop_Indexiv 26
1014 void
1015 __indirect_glIndexiv(const GLint * c)
1016 {
1017 generic_4_byte(X_GLrop_Indexiv, c);
1018 }
1019
1020 #define X_GLrop_Indexsv 27
1021 void
1022 __indirect_glIndexs(GLshort c)
1023 {
1024 __GLXcontext *const gc = __glXGetCurrentContext();
1025 const GLuint cmdlen = 8;
1026 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
1027 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 2);
1028 gc->pc += cmdlen;
1029 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1030 (void) __glXFlushRenderBuffer(gc, gc->pc);
1031 }
1032 }
1033
1034 #define X_GLrop_Indexsv 27
1035 void
1036 __indirect_glIndexsv(const GLshort * c)
1037 {
1038 __GLXcontext *const gc = __glXGetCurrentContext();
1039 const GLuint cmdlen = 8;
1040 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
1041 (void) memcpy((void *) (gc->pc + 4), (void *) (c), 2);
1042 gc->pc += cmdlen;
1043 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1044 (void) __glXFlushRenderBuffer(gc, gc->pc);
1045 }
1046 }
1047
1048 #define X_GLrop_Normal3bv 28
1049 void
1050 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
1051 {
1052 __GLXcontext *const gc = __glXGetCurrentContext();
1053 const GLuint cmdlen = 8;
1054 emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
1055 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 1);
1056 (void) memcpy((void *) (gc->pc + 5), (void *) (&ny), 1);
1057 (void) memcpy((void *) (gc->pc + 6), (void *) (&nz), 1);
1058 gc->pc += cmdlen;
1059 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1060 (void) __glXFlushRenderBuffer(gc, gc->pc);
1061 }
1062 }
1063
1064 #define X_GLrop_Normal3bv 28
1065 void
1066 __indirect_glNormal3bv(const GLbyte *v)
1067 {
1068 generic_3_byte(X_GLrop_Normal3bv, v);
1069 }
1070
1071 #define X_GLrop_Normal3dv 29
1072 void
1073 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
1074 {
1075 __GLXcontext *const gc = __glXGetCurrentContext();
1076 const GLuint cmdlen = 28;
1077 emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
1078 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 8);
1079 (void) memcpy((void *) (gc->pc + 12), (void *) (&ny), 8);
1080 (void) memcpy((void *) (gc->pc + 20), (void *) (&nz), 8);
1081 gc->pc += cmdlen;
1082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1083 (void) __glXFlushRenderBuffer(gc, gc->pc);
1084 }
1085 }
1086
1087 #define X_GLrop_Normal3dv 29
1088 void
1089 __indirect_glNormal3dv(const GLdouble * v)
1090 {
1091 generic_24_byte(X_GLrop_Normal3dv, v);
1092 }
1093
1094 #define X_GLrop_Normal3fv 30
1095 void
1096 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1097 {
1098 __GLXcontext *const gc = __glXGetCurrentContext();
1099 const GLuint cmdlen = 16;
1100 emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
1101 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
1102 (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
1103 (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
1104 gc->pc += cmdlen;
1105 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1106 (void) __glXFlushRenderBuffer(gc, gc->pc);
1107 }
1108 }
1109
1110 #define X_GLrop_Normal3fv 30
1111 void
1112 __indirect_glNormal3fv(const GLfloat * v)
1113 {
1114 generic_12_byte(X_GLrop_Normal3fv, v);
1115 }
1116
1117 #define X_GLrop_Normal3iv 31
1118 void
1119 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
1120 {
1121 __GLXcontext *const gc = __glXGetCurrentContext();
1122 const GLuint cmdlen = 16;
1123 emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
1124 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
1125 (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
1126 (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
1127 gc->pc += cmdlen;
1128 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1129 (void) __glXFlushRenderBuffer(gc, gc->pc);
1130 }
1131 }
1132
1133 #define X_GLrop_Normal3iv 31
1134 void
1135 __indirect_glNormal3iv(const GLint * v)
1136 {
1137 generic_12_byte(X_GLrop_Normal3iv, v);
1138 }
1139
1140 #define X_GLrop_Normal3sv 32
1141 void
1142 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
1143 {
1144 __GLXcontext *const gc = __glXGetCurrentContext();
1145 const GLuint cmdlen = 12;
1146 emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
1147 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 2);
1148 (void) memcpy((void *) (gc->pc + 6), (void *) (&ny), 2);
1149 (void) memcpy((void *) (gc->pc + 8), (void *) (&nz), 2);
1150 gc->pc += cmdlen;
1151 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1152 (void) __glXFlushRenderBuffer(gc, gc->pc);
1153 }
1154 }
1155
1156 #define X_GLrop_Normal3sv 32
1157 void
1158 __indirect_glNormal3sv(const GLshort * v)
1159 {
1160 generic_6_byte(X_GLrop_Normal3sv, v);
1161 }
1162
1163 #define X_GLrop_RasterPos2dv 33
1164 void
1165 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
1166 {
1167 __GLXcontext *const gc = __glXGetCurrentContext();
1168 const GLuint cmdlen = 20;
1169 emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
1170 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1171 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1172 gc->pc += cmdlen;
1173 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1174 (void) __glXFlushRenderBuffer(gc, gc->pc);
1175 }
1176 }
1177
1178 #define X_GLrop_RasterPos2dv 33
1179 void
1180 __indirect_glRasterPos2dv(const GLdouble * v)
1181 {
1182 generic_16_byte(X_GLrop_RasterPos2dv, v);
1183 }
1184
1185 #define X_GLrop_RasterPos2fv 34
1186 void
1187 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
1188 {
1189 __GLXcontext *const gc = __glXGetCurrentContext();
1190 const GLuint cmdlen = 12;
1191 emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1192 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1193 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1194 gc->pc += cmdlen;
1195 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1196 (void) __glXFlushRenderBuffer(gc, gc->pc);
1197 }
1198 }
1199
1200 #define X_GLrop_RasterPos2fv 34
1201 void
1202 __indirect_glRasterPos2fv(const GLfloat * v)
1203 {
1204 generic_8_byte(X_GLrop_RasterPos2fv, v);
1205 }
1206
1207 #define X_GLrop_RasterPos2iv 35
1208 void
1209 __indirect_glRasterPos2i(GLint x, GLint y)
1210 {
1211 __GLXcontext *const gc = __glXGetCurrentContext();
1212 const GLuint cmdlen = 12;
1213 emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1214 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1215 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1216 gc->pc += cmdlen;
1217 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1218 (void) __glXFlushRenderBuffer(gc, gc->pc);
1219 }
1220 }
1221
1222 #define X_GLrop_RasterPos2iv 35
1223 void
1224 __indirect_glRasterPos2iv(const GLint * v)
1225 {
1226 generic_8_byte(X_GLrop_RasterPos2iv, v);
1227 }
1228
1229 #define X_GLrop_RasterPos2sv 36
1230 void
1231 __indirect_glRasterPos2s(GLshort x, GLshort y)
1232 {
1233 __GLXcontext *const gc = __glXGetCurrentContext();
1234 const GLuint cmdlen = 8;
1235 emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1236 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1237 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1238 gc->pc += cmdlen;
1239 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1240 (void) __glXFlushRenderBuffer(gc, gc->pc);
1241 }
1242 }
1243
1244 #define X_GLrop_RasterPos2sv 36
1245 void
1246 __indirect_glRasterPos2sv(const GLshort * v)
1247 {
1248 generic_4_byte(X_GLrop_RasterPos2sv, v);
1249 }
1250
1251 #define X_GLrop_RasterPos3dv 37
1252 void
1253 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1254 {
1255 __GLXcontext *const gc = __glXGetCurrentContext();
1256 const GLuint cmdlen = 28;
1257 emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1258 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1259 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1260 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
1261 gc->pc += cmdlen;
1262 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1263 (void) __glXFlushRenderBuffer(gc, gc->pc);
1264 }
1265 }
1266
1267 #define X_GLrop_RasterPos3dv 37
1268 void
1269 __indirect_glRasterPos3dv(const GLdouble * v)
1270 {
1271 generic_24_byte(X_GLrop_RasterPos3dv, v);
1272 }
1273
1274 #define X_GLrop_RasterPos3fv 38
1275 void
1276 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1277 {
1278 __GLXcontext *const gc = __glXGetCurrentContext();
1279 const GLuint cmdlen = 16;
1280 emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1281 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1282 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1283 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1284 gc->pc += cmdlen;
1285 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1286 (void) __glXFlushRenderBuffer(gc, gc->pc);
1287 }
1288 }
1289
1290 #define X_GLrop_RasterPos3fv 38
1291 void
1292 __indirect_glRasterPos3fv(const GLfloat * v)
1293 {
1294 generic_12_byte(X_GLrop_RasterPos3fv, v);
1295 }
1296
1297 #define X_GLrop_RasterPos3iv 39
1298 void
1299 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1300 {
1301 __GLXcontext *const gc = __glXGetCurrentContext();
1302 const GLuint cmdlen = 16;
1303 emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1304 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1305 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1306 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1307 gc->pc += cmdlen;
1308 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1309 (void) __glXFlushRenderBuffer(gc, gc->pc);
1310 }
1311 }
1312
1313 #define X_GLrop_RasterPos3iv 39
1314 void
1315 __indirect_glRasterPos3iv(const GLint * v)
1316 {
1317 generic_12_byte(X_GLrop_RasterPos3iv, v);
1318 }
1319
1320 #define X_GLrop_RasterPos3sv 40
1321 void
1322 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1323 {
1324 __GLXcontext *const gc = __glXGetCurrentContext();
1325 const GLuint cmdlen = 12;
1326 emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1327 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1328 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1329 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
1330 gc->pc += cmdlen;
1331 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1332 (void) __glXFlushRenderBuffer(gc, gc->pc);
1333 }
1334 }
1335
1336 #define X_GLrop_RasterPos3sv 40
1337 void
1338 __indirect_glRasterPos3sv(const GLshort * v)
1339 {
1340 generic_6_byte(X_GLrop_RasterPos3sv, v);
1341 }
1342
1343 #define X_GLrop_RasterPos4dv 41
1344 void
1345 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1346 {
1347 __GLXcontext *const gc = __glXGetCurrentContext();
1348 const GLuint cmdlen = 36;
1349 emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1350 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1351 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1352 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
1353 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
1354 gc->pc += cmdlen;
1355 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1356 (void) __glXFlushRenderBuffer(gc, gc->pc);
1357 }
1358 }
1359
1360 #define X_GLrop_RasterPos4dv 41
1361 void
1362 __indirect_glRasterPos4dv(const GLdouble * v)
1363 {
1364 generic_32_byte(X_GLrop_RasterPos4dv, v);
1365 }
1366
1367 #define X_GLrop_RasterPos4fv 42
1368 void
1369 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1370 {
1371 __GLXcontext *const gc = __glXGetCurrentContext();
1372 const GLuint cmdlen = 20;
1373 emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1374 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1375 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1376 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1377 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
1378 gc->pc += cmdlen;
1379 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1380 (void) __glXFlushRenderBuffer(gc, gc->pc);
1381 }
1382 }
1383
1384 #define X_GLrop_RasterPos4fv 42
1385 void
1386 __indirect_glRasterPos4fv(const GLfloat * v)
1387 {
1388 generic_16_byte(X_GLrop_RasterPos4fv, v);
1389 }
1390
1391 #define X_GLrop_RasterPos4iv 43
1392 void
1393 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1394 {
1395 __GLXcontext *const gc = __glXGetCurrentContext();
1396 const GLuint cmdlen = 20;
1397 emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1398 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1399 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1400 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1401 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
1402 gc->pc += cmdlen;
1403 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1404 (void) __glXFlushRenderBuffer(gc, gc->pc);
1405 }
1406 }
1407
1408 #define X_GLrop_RasterPos4iv 43
1409 void
1410 __indirect_glRasterPos4iv(const GLint * v)
1411 {
1412 generic_16_byte(X_GLrop_RasterPos4iv, v);
1413 }
1414
1415 #define X_GLrop_RasterPos4sv 44
1416 void
1417 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1418 {
1419 __GLXcontext *const gc = __glXGetCurrentContext();
1420 const GLuint cmdlen = 12;
1421 emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1422 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1423 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1424 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
1425 (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
1426 gc->pc += cmdlen;
1427 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1428 (void) __glXFlushRenderBuffer(gc, gc->pc);
1429 }
1430 }
1431
1432 #define X_GLrop_RasterPos4sv 44
1433 void
1434 __indirect_glRasterPos4sv(const GLshort * v)
1435 {
1436 generic_8_byte(X_GLrop_RasterPos4sv, v);
1437 }
1438
1439 #define X_GLrop_Rectdv 45
1440 void
1441 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1442 {
1443 __GLXcontext *const gc = __glXGetCurrentContext();
1444 const GLuint cmdlen = 36;
1445 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1446 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 8);
1447 (void) memcpy((void *) (gc->pc + 12), (void *) (&y1), 8);
1448 (void) memcpy((void *) (gc->pc + 20), (void *) (&x2), 8);
1449 (void) memcpy((void *) (gc->pc + 28), (void *) (&y2), 8);
1450 gc->pc += cmdlen;
1451 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1452 (void) __glXFlushRenderBuffer(gc, gc->pc);
1453 }
1454 }
1455
1456 #define X_GLrop_Rectdv 45
1457 void
1458 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1459 {
1460 __GLXcontext *const gc = __glXGetCurrentContext();
1461 const GLuint cmdlen = 36;
1462 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1463 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 16);
1464 (void) memcpy((void *) (gc->pc + 20), (void *) (v2), 16);
1465 gc->pc += cmdlen;
1466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1467 (void) __glXFlushRenderBuffer(gc, gc->pc);
1468 }
1469 }
1470
1471 #define X_GLrop_Rectfv 46
1472 void
1473 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1474 {
1475 __GLXcontext *const gc = __glXGetCurrentContext();
1476 const GLuint cmdlen = 20;
1477 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1478 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
1479 (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
1480 (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
1481 (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
1482 gc->pc += cmdlen;
1483 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1484 (void) __glXFlushRenderBuffer(gc, gc->pc);
1485 }
1486 }
1487
1488 #define X_GLrop_Rectfv 46
1489 void
1490 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1491 {
1492 __GLXcontext *const gc = __glXGetCurrentContext();
1493 const GLuint cmdlen = 20;
1494 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1495 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
1496 (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
1497 gc->pc += cmdlen;
1498 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1499 (void) __glXFlushRenderBuffer(gc, gc->pc);
1500 }
1501 }
1502
1503 #define X_GLrop_Rectiv 47
1504 void
1505 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1506 {
1507 __GLXcontext *const gc = __glXGetCurrentContext();
1508 const GLuint cmdlen = 20;
1509 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1510 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
1511 (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
1512 (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
1513 (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
1514 gc->pc += cmdlen;
1515 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1516 (void) __glXFlushRenderBuffer(gc, gc->pc);
1517 }
1518 }
1519
1520 #define X_GLrop_Rectiv 47
1521 void
1522 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1523 {
1524 __GLXcontext *const gc = __glXGetCurrentContext();
1525 const GLuint cmdlen = 20;
1526 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1527 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
1528 (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
1529 gc->pc += cmdlen;
1530 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1531 (void) __glXFlushRenderBuffer(gc, gc->pc);
1532 }
1533 }
1534
1535 #define X_GLrop_Rectsv 48
1536 void
1537 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1538 {
1539 __GLXcontext *const gc = __glXGetCurrentContext();
1540 const GLuint cmdlen = 12;
1541 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1542 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 2);
1543 (void) memcpy((void *) (gc->pc + 6), (void *) (&y1), 2);
1544 (void) memcpy((void *) (gc->pc + 8), (void *) (&x2), 2);
1545 (void) memcpy((void *) (gc->pc + 10), (void *) (&y2), 2);
1546 gc->pc += cmdlen;
1547 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1548 (void) __glXFlushRenderBuffer(gc, gc->pc);
1549 }
1550 }
1551
1552 #define X_GLrop_Rectsv 48
1553 void
1554 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1555 {
1556 __GLXcontext *const gc = __glXGetCurrentContext();
1557 const GLuint cmdlen = 12;
1558 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1559 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 4);
1560 (void) memcpy((void *) (gc->pc + 8), (void *) (v2), 4);
1561 gc->pc += cmdlen;
1562 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1563 (void) __glXFlushRenderBuffer(gc, gc->pc);
1564 }
1565 }
1566
1567 #define X_GLrop_TexCoord1dv 49
1568 void
1569 __indirect_glTexCoord1d(GLdouble s)
1570 {
1571 __GLXcontext *const gc = __glXGetCurrentContext();
1572 const GLuint cmdlen = 12;
1573 emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1574 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1575 gc->pc += cmdlen;
1576 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1577 (void) __glXFlushRenderBuffer(gc, gc->pc);
1578 }
1579 }
1580
1581 #define X_GLrop_TexCoord1dv 49
1582 void
1583 __indirect_glTexCoord1dv(const GLdouble * v)
1584 {
1585 generic_8_byte(X_GLrop_TexCoord1dv, v);
1586 }
1587
1588 #define X_GLrop_TexCoord1fv 50
1589 void
1590 __indirect_glTexCoord1f(GLfloat s)
1591 {
1592 __GLXcontext *const gc = __glXGetCurrentContext();
1593 const GLuint cmdlen = 8;
1594 emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1595 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1596 gc->pc += cmdlen;
1597 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1598 (void) __glXFlushRenderBuffer(gc, gc->pc);
1599 }
1600 }
1601
1602 #define X_GLrop_TexCoord1fv 50
1603 void
1604 __indirect_glTexCoord1fv(const GLfloat * v)
1605 {
1606 generic_4_byte(X_GLrop_TexCoord1fv, v);
1607 }
1608
1609 #define X_GLrop_TexCoord1iv 51
1610 void
1611 __indirect_glTexCoord1i(GLint s)
1612 {
1613 __GLXcontext *const gc = __glXGetCurrentContext();
1614 const GLuint cmdlen = 8;
1615 emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1616 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1617 gc->pc += cmdlen;
1618 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1619 (void) __glXFlushRenderBuffer(gc, gc->pc);
1620 }
1621 }
1622
1623 #define X_GLrop_TexCoord1iv 51
1624 void
1625 __indirect_glTexCoord1iv(const GLint * v)
1626 {
1627 generic_4_byte(X_GLrop_TexCoord1iv, v);
1628 }
1629
1630 #define X_GLrop_TexCoord1sv 52
1631 void
1632 __indirect_glTexCoord1s(GLshort s)
1633 {
1634 __GLXcontext *const gc = __glXGetCurrentContext();
1635 const GLuint cmdlen = 8;
1636 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1637 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1638 gc->pc += cmdlen;
1639 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1640 (void) __glXFlushRenderBuffer(gc, gc->pc);
1641 }
1642 }
1643
1644 #define X_GLrop_TexCoord1sv 52
1645 void
1646 __indirect_glTexCoord1sv(const GLshort * v)
1647 {
1648 __GLXcontext *const gc = __glXGetCurrentContext();
1649 const GLuint cmdlen = 8;
1650 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1651 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 2);
1652 gc->pc += cmdlen;
1653 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1654 (void) __glXFlushRenderBuffer(gc, gc->pc);
1655 }
1656 }
1657
1658 #define X_GLrop_TexCoord2dv 53
1659 void
1660 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1661 {
1662 __GLXcontext *const gc = __glXGetCurrentContext();
1663 const GLuint cmdlen = 20;
1664 emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1665 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1666 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1667 gc->pc += cmdlen;
1668 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1669 (void) __glXFlushRenderBuffer(gc, gc->pc);
1670 }
1671 }
1672
1673 #define X_GLrop_TexCoord2dv 53
1674 void
1675 __indirect_glTexCoord2dv(const GLdouble * v)
1676 {
1677 generic_16_byte(X_GLrop_TexCoord2dv, v);
1678 }
1679
1680 #define X_GLrop_TexCoord2fv 54
1681 void
1682 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1683 {
1684 __GLXcontext *const gc = __glXGetCurrentContext();
1685 const GLuint cmdlen = 12;
1686 emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1687 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1688 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1689 gc->pc += cmdlen;
1690 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1691 (void) __glXFlushRenderBuffer(gc, gc->pc);
1692 }
1693 }
1694
1695 #define X_GLrop_TexCoord2fv 54
1696 void
1697 __indirect_glTexCoord2fv(const GLfloat * v)
1698 {
1699 generic_8_byte(X_GLrop_TexCoord2fv, v);
1700 }
1701
1702 #define X_GLrop_TexCoord2iv 55
1703 void
1704 __indirect_glTexCoord2i(GLint s, GLint t)
1705 {
1706 __GLXcontext *const gc = __glXGetCurrentContext();
1707 const GLuint cmdlen = 12;
1708 emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1709 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1710 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1711 gc->pc += cmdlen;
1712 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1713 (void) __glXFlushRenderBuffer(gc, gc->pc);
1714 }
1715 }
1716
1717 #define X_GLrop_TexCoord2iv 55
1718 void
1719 __indirect_glTexCoord2iv(const GLint * v)
1720 {
1721 generic_8_byte(X_GLrop_TexCoord2iv, v);
1722 }
1723
1724 #define X_GLrop_TexCoord2sv 56
1725 void
1726 __indirect_glTexCoord2s(GLshort s, GLshort t)
1727 {
1728 __GLXcontext *const gc = __glXGetCurrentContext();
1729 const GLuint cmdlen = 8;
1730 emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1731 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1732 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1733 gc->pc += cmdlen;
1734 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1735 (void) __glXFlushRenderBuffer(gc, gc->pc);
1736 }
1737 }
1738
1739 #define X_GLrop_TexCoord2sv 56
1740 void
1741 __indirect_glTexCoord2sv(const GLshort * v)
1742 {
1743 generic_4_byte(X_GLrop_TexCoord2sv, v);
1744 }
1745
1746 #define X_GLrop_TexCoord3dv 57
1747 void
1748 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1749 {
1750 __GLXcontext *const gc = __glXGetCurrentContext();
1751 const GLuint cmdlen = 28;
1752 emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1753 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1754 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1755 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
1756 gc->pc += cmdlen;
1757 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1758 (void) __glXFlushRenderBuffer(gc, gc->pc);
1759 }
1760 }
1761
1762 #define X_GLrop_TexCoord3dv 57
1763 void
1764 __indirect_glTexCoord3dv(const GLdouble * v)
1765 {
1766 generic_24_byte(X_GLrop_TexCoord3dv, v);
1767 }
1768
1769 #define X_GLrop_TexCoord3fv 58
1770 void
1771 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1772 {
1773 __GLXcontext *const gc = __glXGetCurrentContext();
1774 const GLuint cmdlen = 16;
1775 emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1776 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1777 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1778 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1779 gc->pc += cmdlen;
1780 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1781 (void) __glXFlushRenderBuffer(gc, gc->pc);
1782 }
1783 }
1784
1785 #define X_GLrop_TexCoord3fv 58
1786 void
1787 __indirect_glTexCoord3fv(const GLfloat * v)
1788 {
1789 generic_12_byte(X_GLrop_TexCoord3fv, v);
1790 }
1791
1792 #define X_GLrop_TexCoord3iv 59
1793 void
1794 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1795 {
1796 __GLXcontext *const gc = __glXGetCurrentContext();
1797 const GLuint cmdlen = 16;
1798 emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1799 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1800 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1801 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1802 gc->pc += cmdlen;
1803 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1804 (void) __glXFlushRenderBuffer(gc, gc->pc);
1805 }
1806 }
1807
1808 #define X_GLrop_TexCoord3iv 59
1809 void
1810 __indirect_glTexCoord3iv(const GLint * v)
1811 {
1812 generic_12_byte(X_GLrop_TexCoord3iv, v);
1813 }
1814
1815 #define X_GLrop_TexCoord3sv 60
1816 void
1817 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1818 {
1819 __GLXcontext *const gc = __glXGetCurrentContext();
1820 const GLuint cmdlen = 12;
1821 emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1822 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1823 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1824 (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
1825 gc->pc += cmdlen;
1826 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1827 (void) __glXFlushRenderBuffer(gc, gc->pc);
1828 }
1829 }
1830
1831 #define X_GLrop_TexCoord3sv 60
1832 void
1833 __indirect_glTexCoord3sv(const GLshort * v)
1834 {
1835 generic_6_byte(X_GLrop_TexCoord3sv, v);
1836 }
1837
1838 #define X_GLrop_TexCoord4dv 61
1839 void
1840 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1841 {
1842 __GLXcontext *const gc = __glXGetCurrentContext();
1843 const GLuint cmdlen = 36;
1844 emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1845 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1846 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1847 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
1848 (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
1849 gc->pc += cmdlen;
1850 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1851 (void) __glXFlushRenderBuffer(gc, gc->pc);
1852 }
1853 }
1854
1855 #define X_GLrop_TexCoord4dv 61
1856 void
1857 __indirect_glTexCoord4dv(const GLdouble * v)
1858 {
1859 generic_32_byte(X_GLrop_TexCoord4dv, v);
1860 }
1861
1862 #define X_GLrop_TexCoord4fv 62
1863 void
1864 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1865 {
1866 __GLXcontext *const gc = __glXGetCurrentContext();
1867 const GLuint cmdlen = 20;
1868 emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1869 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1870 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1871 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1872 (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
1873 gc->pc += cmdlen;
1874 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1875 (void) __glXFlushRenderBuffer(gc, gc->pc);
1876 }
1877 }
1878
1879 #define X_GLrop_TexCoord4fv 62
1880 void
1881 __indirect_glTexCoord4fv(const GLfloat * v)
1882 {
1883 generic_16_byte(X_GLrop_TexCoord4fv, v);
1884 }
1885
1886 #define X_GLrop_TexCoord4iv 63
1887 void
1888 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1889 {
1890 __GLXcontext *const gc = __glXGetCurrentContext();
1891 const GLuint cmdlen = 20;
1892 emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1893 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1894 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1895 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1896 (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
1897 gc->pc += cmdlen;
1898 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1899 (void) __glXFlushRenderBuffer(gc, gc->pc);
1900 }
1901 }
1902
1903 #define X_GLrop_TexCoord4iv 63
1904 void
1905 __indirect_glTexCoord4iv(const GLint * v)
1906 {
1907 generic_16_byte(X_GLrop_TexCoord4iv, v);
1908 }
1909
1910 #define X_GLrop_TexCoord4sv 64
1911 void
1912 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1913 {
1914 __GLXcontext *const gc = __glXGetCurrentContext();
1915 const GLuint cmdlen = 12;
1916 emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1917 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1918 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1919 (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
1920 (void) memcpy((void *) (gc->pc + 10), (void *) (&q), 2);
1921 gc->pc += cmdlen;
1922 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1923 (void) __glXFlushRenderBuffer(gc, gc->pc);
1924 }
1925 }
1926
1927 #define X_GLrop_TexCoord4sv 64
1928 void
1929 __indirect_glTexCoord4sv(const GLshort * v)
1930 {
1931 generic_8_byte(X_GLrop_TexCoord4sv, v);
1932 }
1933
1934 #define X_GLrop_Vertex2dv 65
1935 void
1936 __indirect_glVertex2d(GLdouble x, GLdouble y)
1937 {
1938 __GLXcontext *const gc = __glXGetCurrentContext();
1939 const GLuint cmdlen = 20;
1940 emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1941 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1942 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1943 gc->pc += cmdlen;
1944 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1945 (void) __glXFlushRenderBuffer(gc, gc->pc);
1946 }
1947 }
1948
1949 #define X_GLrop_Vertex2dv 65
1950 void
1951 __indirect_glVertex2dv(const GLdouble * v)
1952 {
1953 generic_16_byte(X_GLrop_Vertex2dv, v);
1954 }
1955
1956 #define X_GLrop_Vertex2fv 66
1957 void
1958 __indirect_glVertex2f(GLfloat x, GLfloat y)
1959 {
1960 __GLXcontext *const gc = __glXGetCurrentContext();
1961 const GLuint cmdlen = 12;
1962 emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1963 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1964 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1965 gc->pc += cmdlen;
1966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1967 (void) __glXFlushRenderBuffer(gc, gc->pc);
1968 }
1969 }
1970
1971 #define X_GLrop_Vertex2fv 66
1972 void
1973 __indirect_glVertex2fv(const GLfloat * v)
1974 {
1975 generic_8_byte(X_GLrop_Vertex2fv, v);
1976 }
1977
1978 #define X_GLrop_Vertex2iv 67
1979 void
1980 __indirect_glVertex2i(GLint x, GLint y)
1981 {
1982 __GLXcontext *const gc = __glXGetCurrentContext();
1983 const GLuint cmdlen = 12;
1984 emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1985 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1986 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1987 gc->pc += cmdlen;
1988 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1989 (void) __glXFlushRenderBuffer(gc, gc->pc);
1990 }
1991 }
1992
1993 #define X_GLrop_Vertex2iv 67
1994 void
1995 __indirect_glVertex2iv(const GLint * v)
1996 {
1997 generic_8_byte(X_GLrop_Vertex2iv, v);
1998 }
1999
2000 #define X_GLrop_Vertex2sv 68
2001 void
2002 __indirect_glVertex2s(GLshort x, GLshort y)
2003 {
2004 __GLXcontext *const gc = __glXGetCurrentContext();
2005 const GLuint cmdlen = 8;
2006 emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
2007 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2008 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2009 gc->pc += cmdlen;
2010 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2011 (void) __glXFlushRenderBuffer(gc, gc->pc);
2012 }
2013 }
2014
2015 #define X_GLrop_Vertex2sv 68
2016 void
2017 __indirect_glVertex2sv(const GLshort * v)
2018 {
2019 generic_4_byte(X_GLrop_Vertex2sv, v);
2020 }
2021
2022 #define X_GLrop_Vertex3dv 69
2023 void
2024 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
2025 {
2026 __GLXcontext *const gc = __glXGetCurrentContext();
2027 const GLuint cmdlen = 28;
2028 emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
2029 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
2030 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
2031 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
2032 gc->pc += cmdlen;
2033 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2034 (void) __glXFlushRenderBuffer(gc, gc->pc);
2035 }
2036 }
2037
2038 #define X_GLrop_Vertex3dv 69
2039 void
2040 __indirect_glVertex3dv(const GLdouble * v)
2041 {
2042 generic_24_byte(X_GLrop_Vertex3dv, v);
2043 }
2044
2045 #define X_GLrop_Vertex3fv 70
2046 void
2047 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
2048 {
2049 __GLXcontext *const gc = __glXGetCurrentContext();
2050 const GLuint cmdlen = 16;
2051 emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
2052 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2053 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2054 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2055 gc->pc += cmdlen;
2056 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2057 (void) __glXFlushRenderBuffer(gc, gc->pc);
2058 }
2059 }
2060
2061 #define X_GLrop_Vertex3fv 70
2062 void
2063 __indirect_glVertex3fv(const GLfloat * v)
2064 {
2065 generic_12_byte(X_GLrop_Vertex3fv, v);
2066 }
2067
2068 #define X_GLrop_Vertex3iv 71
2069 void
2070 __indirect_glVertex3i(GLint x, GLint y, GLint z)
2071 {
2072 __GLXcontext *const gc = __glXGetCurrentContext();
2073 const GLuint cmdlen = 16;
2074 emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
2075 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2076 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2077 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2078 gc->pc += cmdlen;
2079 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2080 (void) __glXFlushRenderBuffer(gc, gc->pc);
2081 }
2082 }
2083
2084 #define X_GLrop_Vertex3iv 71
2085 void
2086 __indirect_glVertex3iv(const GLint * v)
2087 {
2088 generic_12_byte(X_GLrop_Vertex3iv, v);
2089 }
2090
2091 #define X_GLrop_Vertex3sv 72
2092 void
2093 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
2094 {
2095 __GLXcontext *const gc = __glXGetCurrentContext();
2096 const GLuint cmdlen = 12;
2097 emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
2098 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2099 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2100 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
2101 gc->pc += cmdlen;
2102 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2103 (void) __glXFlushRenderBuffer(gc, gc->pc);
2104 }
2105 }
2106
2107 #define X_GLrop_Vertex3sv 72
2108 void
2109 __indirect_glVertex3sv(const GLshort * v)
2110 {
2111 generic_6_byte(X_GLrop_Vertex3sv, v);
2112 }
2113
2114 #define X_GLrop_Vertex4dv 73
2115 void
2116 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2117 {
2118 __GLXcontext *const gc = __glXGetCurrentContext();
2119 const GLuint cmdlen = 36;
2120 emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
2121 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
2122 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
2123 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
2124 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
2125 gc->pc += cmdlen;
2126 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2127 (void) __glXFlushRenderBuffer(gc, gc->pc);
2128 }
2129 }
2130
2131 #define X_GLrop_Vertex4dv 73
2132 void
2133 __indirect_glVertex4dv(const GLdouble * v)
2134 {
2135 generic_32_byte(X_GLrop_Vertex4dv, v);
2136 }
2137
2138 #define X_GLrop_Vertex4fv 74
2139 void
2140 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2141 {
2142 __GLXcontext *const gc = __glXGetCurrentContext();
2143 const GLuint cmdlen = 20;
2144 emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
2145 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2146 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2147 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2148 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
2149 gc->pc += cmdlen;
2150 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2151 (void) __glXFlushRenderBuffer(gc, gc->pc);
2152 }
2153 }
2154
2155 #define X_GLrop_Vertex4fv 74
2156 void
2157 __indirect_glVertex4fv(const GLfloat * v)
2158 {
2159 generic_16_byte(X_GLrop_Vertex4fv, v);
2160 }
2161
2162 #define X_GLrop_Vertex4iv 75
2163 void
2164 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
2165 {
2166 __GLXcontext *const gc = __glXGetCurrentContext();
2167 const GLuint cmdlen = 20;
2168 emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
2169 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2170 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2171 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2172 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
2173 gc->pc += cmdlen;
2174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2175 (void) __glXFlushRenderBuffer(gc, gc->pc);
2176 }
2177 }
2178
2179 #define X_GLrop_Vertex4iv 75
2180 void
2181 __indirect_glVertex4iv(const GLint * v)
2182 {
2183 generic_16_byte(X_GLrop_Vertex4iv, v);
2184 }
2185
2186 #define X_GLrop_Vertex4sv 76
2187 void
2188 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2189 {
2190 __GLXcontext *const gc = __glXGetCurrentContext();
2191 const GLuint cmdlen = 12;
2192 emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
2193 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2194 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2195 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
2196 (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
2197 gc->pc += cmdlen;
2198 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2199 (void) __glXFlushRenderBuffer(gc, gc->pc);
2200 }
2201 }
2202
2203 #define X_GLrop_Vertex4sv 76
2204 void
2205 __indirect_glVertex4sv(const GLshort * v)
2206 {
2207 generic_8_byte(X_GLrop_Vertex4sv, v);
2208 }
2209
2210 #define X_GLrop_ClipPlane 77
2211 void
2212 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
2213 {
2214 __GLXcontext *const gc = __glXGetCurrentContext();
2215 const GLuint cmdlen = 40;
2216 emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
2217 (void) memcpy((void *) (gc->pc + 4), (void *) (equation), 32);
2218 (void) memcpy((void *) (gc->pc + 36), (void *) (&plane), 4);
2219 gc->pc += cmdlen;
2220 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2221 (void) __glXFlushRenderBuffer(gc, gc->pc);
2222 }
2223 }
2224
2225 #define X_GLrop_ColorMaterial 78
2226 void
2227 __indirect_glColorMaterial(GLenum face, GLenum mode)
2228 {
2229 __GLXcontext *const gc = __glXGetCurrentContext();
2230 const GLuint cmdlen = 12;
2231 emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
2232 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2233 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2234 gc->pc += cmdlen;
2235 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2236 (void) __glXFlushRenderBuffer(gc, gc->pc);
2237 }
2238 }
2239
2240 #define X_GLrop_CullFace 79
2241 void
2242 __indirect_glCullFace(GLenum mode)
2243 {
2244 __GLXcontext *const gc = __glXGetCurrentContext();
2245 const GLuint cmdlen = 8;
2246 emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
2247 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2248 gc->pc += cmdlen;
2249 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2250 (void) __glXFlushRenderBuffer(gc, gc->pc);
2251 }
2252 }
2253
2254 #define X_GLrop_Fogf 80
2255 void
2256 __indirect_glFogf(GLenum pname, GLfloat param)
2257 {
2258 __GLXcontext *const gc = __glXGetCurrentContext();
2259 const GLuint cmdlen = 12;
2260 emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
2261 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2262 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2263 gc->pc += cmdlen;
2264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2265 (void) __glXFlushRenderBuffer(gc, gc->pc);
2266 }
2267 }
2268
2269 #define X_GLrop_Fogfv 81
2270 void
2271 __indirect_glFogfv(GLenum pname, const GLfloat * params)
2272 {
2273 __GLXcontext *const gc = __glXGetCurrentContext();
2274 const GLuint compsize = __glFogfv_size(pname);
2275 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2276 emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
2277 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2278 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2279 gc->pc += cmdlen;
2280 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2281 (void) __glXFlushRenderBuffer(gc, gc->pc);
2282 }
2283 }
2284
2285 #define X_GLrop_Fogi 82
2286 void
2287 __indirect_glFogi(GLenum pname, GLint param)
2288 {
2289 __GLXcontext *const gc = __glXGetCurrentContext();
2290 const GLuint cmdlen = 12;
2291 emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
2292 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2293 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2294 gc->pc += cmdlen;
2295 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2296 (void) __glXFlushRenderBuffer(gc, gc->pc);
2297 }
2298 }
2299
2300 #define X_GLrop_Fogiv 83
2301 void
2302 __indirect_glFogiv(GLenum pname, const GLint * params)
2303 {
2304 __GLXcontext *const gc = __glXGetCurrentContext();
2305 const GLuint compsize = __glFogiv_size(pname);
2306 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2307 emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
2308 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2309 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2310 gc->pc += cmdlen;
2311 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2312 (void) __glXFlushRenderBuffer(gc, gc->pc);
2313 }
2314 }
2315
2316 #define X_GLrop_FrontFace 84
2317 void
2318 __indirect_glFrontFace(GLenum mode)
2319 {
2320 __GLXcontext *const gc = __glXGetCurrentContext();
2321 const GLuint cmdlen = 8;
2322 emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
2323 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2324 gc->pc += cmdlen;
2325 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2326 (void) __glXFlushRenderBuffer(gc, gc->pc);
2327 }
2328 }
2329
2330 #define X_GLrop_Hint 85
2331 void
2332 __indirect_glHint(GLenum target, GLenum mode)
2333 {
2334 __GLXcontext *const gc = __glXGetCurrentContext();
2335 const GLuint cmdlen = 12;
2336 emit_header(gc->pc, X_GLrop_Hint, cmdlen);
2337 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2338 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2339 gc->pc += cmdlen;
2340 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2341 (void) __glXFlushRenderBuffer(gc, gc->pc);
2342 }
2343 }
2344
2345 #define X_GLrop_Lightf 86
2346 void
2347 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
2348 {
2349 __GLXcontext *const gc = __glXGetCurrentContext();
2350 const GLuint cmdlen = 16;
2351 emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
2352 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2353 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2354 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2355 gc->pc += cmdlen;
2356 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2357 (void) __glXFlushRenderBuffer(gc, gc->pc);
2358 }
2359 }
2360
2361 #define X_GLrop_Lightfv 87
2362 void
2363 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
2364 {
2365 __GLXcontext *const gc = __glXGetCurrentContext();
2366 const GLuint compsize = __glLightfv_size(pname);
2367 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2368 emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
2369 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2370 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2371 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2372 gc->pc += cmdlen;
2373 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2374 (void) __glXFlushRenderBuffer(gc, gc->pc);
2375 }
2376 }
2377
2378 #define X_GLrop_Lighti 88
2379 void
2380 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2381 {
2382 __GLXcontext *const gc = __glXGetCurrentContext();
2383 const GLuint cmdlen = 16;
2384 emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2385 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2386 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2387 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2388 gc->pc += cmdlen;
2389 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2390 (void) __glXFlushRenderBuffer(gc, gc->pc);
2391 }
2392 }
2393
2394 #define X_GLrop_Lightiv 89
2395 void
2396 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2397 {
2398 __GLXcontext *const gc = __glXGetCurrentContext();
2399 const GLuint compsize = __glLightiv_size(pname);
2400 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2401 emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2402 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2403 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2404 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2405 gc->pc += cmdlen;
2406 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2407 (void) __glXFlushRenderBuffer(gc, gc->pc);
2408 }
2409 }
2410
2411 #define X_GLrop_LightModelf 90
2412 void
2413 __indirect_glLightModelf(GLenum pname, GLfloat param)
2414 {
2415 __GLXcontext *const gc = __glXGetCurrentContext();
2416 const GLuint cmdlen = 12;
2417 emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2418 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2419 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2420 gc->pc += cmdlen;
2421 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2422 (void) __glXFlushRenderBuffer(gc, gc->pc);
2423 }
2424 }
2425
2426 #define X_GLrop_LightModelfv 91
2427 void
2428 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2429 {
2430 __GLXcontext *const gc = __glXGetCurrentContext();
2431 const GLuint compsize = __glLightModelfv_size(pname);
2432 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2433 emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2434 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2435 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2436 gc->pc += cmdlen;
2437 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2438 (void) __glXFlushRenderBuffer(gc, gc->pc);
2439 }
2440 }
2441
2442 #define X_GLrop_LightModeli 92
2443 void
2444 __indirect_glLightModeli(GLenum pname, GLint param)
2445 {
2446 __GLXcontext *const gc = __glXGetCurrentContext();
2447 const GLuint cmdlen = 12;
2448 emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2449 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2450 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2451 gc->pc += cmdlen;
2452 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2453 (void) __glXFlushRenderBuffer(gc, gc->pc);
2454 }
2455 }
2456
2457 #define X_GLrop_LightModeliv 93
2458 void
2459 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2460 {
2461 __GLXcontext *const gc = __glXGetCurrentContext();
2462 const GLuint compsize = __glLightModeliv_size(pname);
2463 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2464 emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2465 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2466 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2467 gc->pc += cmdlen;
2468 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2469 (void) __glXFlushRenderBuffer(gc, gc->pc);
2470 }
2471 }
2472
2473 #define X_GLrop_LineStipple 94
2474 void
2475 __indirect_glLineStipple(GLint factor, GLushort pattern)
2476 {
2477 __GLXcontext *const gc = __glXGetCurrentContext();
2478 const GLuint cmdlen = 12;
2479 emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2480 (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
2481 (void) memcpy((void *) (gc->pc + 8), (void *) (&pattern), 2);
2482 gc->pc += cmdlen;
2483 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2484 (void) __glXFlushRenderBuffer(gc, gc->pc);
2485 }
2486 }
2487
2488 #define X_GLrop_LineWidth 95
2489 void
2490 __indirect_glLineWidth(GLfloat width)
2491 {
2492 __GLXcontext *const gc = __glXGetCurrentContext();
2493 const GLuint cmdlen = 8;
2494 emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2495 (void) memcpy((void *) (gc->pc + 4), (void *) (&width), 4);
2496 gc->pc += cmdlen;
2497 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2498 (void) __glXFlushRenderBuffer(gc, gc->pc);
2499 }
2500 }
2501
2502 #define X_GLrop_Materialf 96
2503 void
2504 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2505 {
2506 __GLXcontext *const gc = __glXGetCurrentContext();
2507 const GLuint cmdlen = 16;
2508 emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2509 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2510 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2511 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2512 gc->pc += cmdlen;
2513 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2514 (void) __glXFlushRenderBuffer(gc, gc->pc);
2515 }
2516 }
2517
2518 #define X_GLrop_Materialfv 97
2519 void
2520 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2521 {
2522 __GLXcontext *const gc = __glXGetCurrentContext();
2523 const GLuint compsize = __glMaterialfv_size(pname);
2524 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2525 emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2526 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2527 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2528 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2529 gc->pc += cmdlen;
2530 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2531 (void) __glXFlushRenderBuffer(gc, gc->pc);
2532 }
2533 }
2534
2535 #define X_GLrop_Materiali 98
2536 void
2537 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2538 {
2539 __GLXcontext *const gc = __glXGetCurrentContext();
2540 const GLuint cmdlen = 16;
2541 emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2542 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2543 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2544 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2545 gc->pc += cmdlen;
2546 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2547 (void) __glXFlushRenderBuffer(gc, gc->pc);
2548 }
2549 }
2550
2551 #define X_GLrop_Materialiv 99
2552 void
2553 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2554 {
2555 __GLXcontext *const gc = __glXGetCurrentContext();
2556 const GLuint compsize = __glMaterialiv_size(pname);
2557 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2558 emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2559 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2560 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2561 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2562 gc->pc += cmdlen;
2563 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2564 (void) __glXFlushRenderBuffer(gc, gc->pc);
2565 }
2566 }
2567
2568 #define X_GLrop_PointSize 100
2569 void
2570 __indirect_glPointSize(GLfloat size)
2571 {
2572 __GLXcontext *const gc = __glXGetCurrentContext();
2573 const GLuint cmdlen = 8;
2574 emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2575 (void) memcpy((void *) (gc->pc + 4), (void *) (&size), 4);
2576 gc->pc += cmdlen;
2577 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2578 (void) __glXFlushRenderBuffer(gc, gc->pc);
2579 }
2580 }
2581
2582 #define X_GLrop_PolygonMode 101
2583 void
2584 __indirect_glPolygonMode(GLenum face, GLenum mode)
2585 {
2586 __GLXcontext *const gc = __glXGetCurrentContext();
2587 const GLuint cmdlen = 12;
2588 emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2589 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2590 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2591 gc->pc += cmdlen;
2592 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2593 (void) __glXFlushRenderBuffer(gc, gc->pc);
2594 }
2595 }
2596
2597 #define X_GLrop_PolygonStipple 102
2598 void
2599 __indirect_glPolygonStipple(const GLubyte *mask)
2600 {
2601 __GLXcontext *const gc = __glXGetCurrentContext();
2602 const GLuint compsize =
2603 (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
2604 0) : 0;
2605 const GLuint cmdlen = 24 + __GLX_PAD(compsize);
2606 emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
2607 if (compsize > 0) {
2608 (*gc->fillImage) (gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask,
2609 gc->pc + 24, gc->pc + 4);
2610 } else {
2611 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
2612 default_pixel_store_2D_size);
2613 }
2614 gc->pc += cmdlen;
2615 if (gc->pc > gc->limit) {
2616 (void) __glXFlushRenderBuffer(gc, gc->pc);
2617 }
2618 }
2619
2620 #define X_GLrop_Scissor 103
2621 void
2622 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2623 {
2624 __GLXcontext *const gc = __glXGetCurrentContext();
2625 const GLuint cmdlen = 20;
2626 emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2627 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2628 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2629 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
2630 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
2631 gc->pc += cmdlen;
2632 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2633 (void) __glXFlushRenderBuffer(gc, gc->pc);
2634 }
2635 }
2636
2637 #define X_GLrop_ShadeModel 104
2638 void
2639 __indirect_glShadeModel(GLenum mode)
2640 {
2641 __GLXcontext *const gc = __glXGetCurrentContext();
2642 const GLuint cmdlen = 8;
2643 emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2644 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2645 gc->pc += cmdlen;
2646 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2647 (void) __glXFlushRenderBuffer(gc, gc->pc);
2648 }
2649 }
2650
2651 #define X_GLrop_TexParameterf 105
2652 void
2653 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2654 {
2655 __GLXcontext *const gc = __glXGetCurrentContext();
2656 const GLuint cmdlen = 16;
2657 emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2658 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2659 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2660 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2661 gc->pc += cmdlen;
2662 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2663 (void) __glXFlushRenderBuffer(gc, gc->pc);
2664 }
2665 }
2666
2667 #define X_GLrop_TexParameterfv 106
2668 void
2669 __indirect_glTexParameterfv(GLenum target, GLenum pname,
2670 const GLfloat * params)
2671 {
2672 __GLXcontext *const gc = __glXGetCurrentContext();
2673 const GLuint compsize = __glTexParameterfv_size(pname);
2674 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2675 emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2676 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2677 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2678 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2679 gc->pc += cmdlen;
2680 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2681 (void) __glXFlushRenderBuffer(gc, gc->pc);
2682 }
2683 }
2684
2685 #define X_GLrop_TexParameteri 107
2686 void
2687 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2688 {
2689 __GLXcontext *const gc = __glXGetCurrentContext();
2690 const GLuint cmdlen = 16;
2691 emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2692 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2693 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2694 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2695 gc->pc += cmdlen;
2696 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2697 (void) __glXFlushRenderBuffer(gc, gc->pc);
2698 }
2699 }
2700
2701 #define X_GLrop_TexParameteriv 108
2702 void
2703 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2704 {
2705 __GLXcontext *const gc = __glXGetCurrentContext();
2706 const GLuint compsize = __glTexParameteriv_size(pname);
2707 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2708 emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2709 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2710 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2711 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2712 gc->pc += cmdlen;
2713 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2714 (void) __glXFlushRenderBuffer(gc, gc->pc);
2715 }
2716 }
2717
2718 static void
2719 __glx_TexImage_1D2D(unsigned opcode, unsigned dim, GLenum target, GLint level,
2720 GLint internalformat, GLsizei width, GLsizei height,
2721 GLint border, GLenum format, GLenum type,
2722 const GLvoid * pixels)
2723 {
2724 __GLXcontext *const gc = __glXGetCurrentContext();
2725 const GLuint compsize =
2726 __glImageSize(width, height, 1, format, type, target);
2727 const GLuint cmdlen = 56 + __GLX_PAD(compsize);
2728 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
2729 if (cmdlen <= gc->maxSmallRenderCommandSize) {
2730 if ((gc->pc + cmdlen) > gc->bufEnd) {
2731 (void) __glXFlushRenderBuffer(gc, gc->pc);
2732 }
2733 emit_header(gc->pc, opcode, cmdlen);
2734 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
2735 (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
2736 (void) memcpy((void *) (gc->pc + 32), (void *) (&internalformat),
2737 4);
2738 (void) memcpy((void *) (gc->pc + 36), (void *) (&width), 4);
2739 (void) memcpy((void *) (gc->pc + 40), (void *) (&height), 4);
2740 (void) memcpy((void *) (gc->pc + 44), (void *) (&border), 4);
2741 (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
2742 (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
2743 if ((compsize > 0) && (pixels != NULL)) {
2744 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
2745 pixels, gc->pc + 56, gc->pc + 4);
2746 } else {
2747 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
2748 default_pixel_store_2D_size);
2749 }
2750 gc->pc += cmdlen;
2751 if (gc->pc > gc->limit) {
2752 (void) __glXFlushRenderBuffer(gc, gc->pc);
2753 }
2754 } else {
2755 const GLint op = opcode;
2756 const GLuint cmdlenLarge = cmdlen + 4;
2757 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
2758 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
2759 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
2760 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
2761 (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
2762 (void) memcpy((void *) (pc + 36), (void *) (&internalformat), 4);
2763 (void) memcpy((void *) (pc + 40), (void *) (&width), 4);
2764 (void) memcpy((void *) (pc + 44), (void *) (&height), 4);
2765 (void) memcpy((void *) (pc + 48), (void *) (&border), 4);
2766 (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
2767 (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
2768 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
2769 type, pixels, pc + 60, pc + 8);
2770 }
2771 }
2772 }
2773
2774 #define X_GLrop_TexImage1D 109
2775 void
2776 __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat,
2777 GLsizei width, GLint border, GLenum format,
2778 GLenum type, const GLvoid * pixels)
2779 {
2780 __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat,
2781 width, 1, border, format, type, pixels);
2782 }
2783
2784 #define X_GLrop_TexImage2D 110
2785 void
2786 __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat,
2787 GLsizei width, GLsizei height, GLint border,
2788 GLenum format, GLenum type, const GLvoid * pixels)
2789 {
2790 __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat,
2791 width, height, border, format, type, pixels);
2792 }
2793
2794 #define X_GLrop_TexEnvf 111
2795 void
2796 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2797 {
2798 __GLXcontext *const gc = __glXGetCurrentContext();
2799 const GLuint cmdlen = 16;
2800 emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2801 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2802 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2803 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2804 gc->pc += cmdlen;
2805 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2806 (void) __glXFlushRenderBuffer(gc, gc->pc);
2807 }
2808 }
2809
2810 #define X_GLrop_TexEnvfv 112
2811 void
2812 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2813 {
2814 __GLXcontext *const gc = __glXGetCurrentContext();
2815 const GLuint compsize = __glTexEnvfv_size(pname);
2816 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2817 emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2818 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2819 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2820 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2821 gc->pc += cmdlen;
2822 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2823 (void) __glXFlushRenderBuffer(gc, gc->pc);
2824 }
2825 }
2826
2827 #define X_GLrop_TexEnvi 113
2828 void
2829 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2830 {
2831 __GLXcontext *const gc = __glXGetCurrentContext();
2832 const GLuint cmdlen = 16;
2833 emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2834 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2835 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2836 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2837 gc->pc += cmdlen;
2838 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2839 (void) __glXFlushRenderBuffer(gc, gc->pc);
2840 }
2841 }
2842
2843 #define X_GLrop_TexEnviv 114
2844 void
2845 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2846 {
2847 __GLXcontext *const gc = __glXGetCurrentContext();
2848 const GLuint compsize = __glTexEnviv_size(pname);
2849 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2850 emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2851 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2852 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2853 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2854 gc->pc += cmdlen;
2855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2856 (void) __glXFlushRenderBuffer(gc, gc->pc);
2857 }
2858 }
2859
2860 #define X_GLrop_TexGend 115
2861 void
2862 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2863 {
2864 __GLXcontext *const gc = __glXGetCurrentContext();
2865 const GLuint cmdlen = 20;
2866 emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2867 (void) memcpy((void *) (gc->pc + 4), (void *) (&param), 8);
2868 (void) memcpy((void *) (gc->pc + 12), (void *) (&coord), 4);
2869 (void) memcpy((void *) (gc->pc + 16), (void *) (&pname), 4);
2870 gc->pc += cmdlen;
2871 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2872 (void) __glXFlushRenderBuffer(gc, gc->pc);
2873 }
2874 }
2875
2876 #define X_GLrop_TexGendv 116
2877 void
2878 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2879 {
2880 __GLXcontext *const gc = __glXGetCurrentContext();
2881 const GLuint compsize = __glTexGendv_size(pname);
2882 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2883 emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2884 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2885 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2886 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 8));
2887 gc->pc += cmdlen;
2888 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2889 (void) __glXFlushRenderBuffer(gc, gc->pc);
2890 }
2891 }
2892
2893 #define X_GLrop_TexGenf 117
2894 void
2895 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2896 {
2897 __GLXcontext *const gc = __glXGetCurrentContext();
2898 const GLuint cmdlen = 16;
2899 emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2900 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2901 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2902 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2903 gc->pc += cmdlen;
2904 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2905 (void) __glXFlushRenderBuffer(gc, gc->pc);
2906 }
2907 }
2908
2909 #define X_GLrop_TexGenfv 118
2910 void
2911 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2912 {
2913 __GLXcontext *const gc = __glXGetCurrentContext();
2914 const GLuint compsize = __glTexGenfv_size(pname);
2915 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2916 emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2917 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2918 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2919 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2920 gc->pc += cmdlen;
2921 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2922 (void) __glXFlushRenderBuffer(gc, gc->pc);
2923 }
2924 }
2925
2926 #define X_GLrop_TexGeni 119
2927 void
2928 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2929 {
2930 __GLXcontext *const gc = __glXGetCurrentContext();
2931 const GLuint cmdlen = 16;
2932 emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2933 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2934 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2935 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2936 gc->pc += cmdlen;
2937 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2938 (void) __glXFlushRenderBuffer(gc, gc->pc);
2939 }
2940 }
2941
2942 #define X_GLrop_TexGeniv 120
2943 void
2944 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2945 {
2946 __GLXcontext *const gc = __glXGetCurrentContext();
2947 const GLuint compsize = __glTexGeniv_size(pname);
2948 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2949 emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2950 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2951 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2952 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2953 gc->pc += cmdlen;
2954 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2955 (void) __glXFlushRenderBuffer(gc, gc->pc);
2956 }
2957 }
2958
2959 #define X_GLrop_InitNames 121
2960 void
2961 __indirect_glInitNames(void)
2962 {
2963 __GLXcontext *const gc = __glXGetCurrentContext();
2964 const GLuint cmdlen = 4;
2965 emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2966 gc->pc += cmdlen;
2967 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2968 (void) __glXFlushRenderBuffer(gc, gc->pc);
2969 }
2970 }
2971
2972 #define X_GLrop_LoadName 122
2973 void
2974 __indirect_glLoadName(GLuint name)
2975 {
2976 __GLXcontext *const gc = __glXGetCurrentContext();
2977 const GLuint cmdlen = 8;
2978 emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2979 (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
2980 gc->pc += cmdlen;
2981 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2982 (void) __glXFlushRenderBuffer(gc, gc->pc);
2983 }
2984 }
2985
2986 #define X_GLrop_PassThrough 123
2987 void
2988 __indirect_glPassThrough(GLfloat token)
2989 {
2990 __GLXcontext *const gc = __glXGetCurrentContext();
2991 const GLuint cmdlen = 8;
2992 emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2993 (void) memcpy((void *) (gc->pc + 4), (void *) (&token), 4);
2994 gc->pc += cmdlen;
2995 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2996 (void) __glXFlushRenderBuffer(gc, gc->pc);
2997 }
2998 }
2999
3000 #define X_GLrop_PopName 124
3001 void
3002 __indirect_glPopName(void)
3003 {
3004 __GLXcontext *const gc = __glXGetCurrentContext();
3005 const GLuint cmdlen = 4;
3006 emit_header(gc->pc, X_GLrop_PopName, cmdlen);
3007 gc->pc += cmdlen;
3008 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3009 (void) __glXFlushRenderBuffer(gc, gc->pc);
3010 }
3011 }
3012
3013 #define X_GLrop_PushName 125
3014 void
3015 __indirect_glPushName(GLuint name)
3016 {
3017 __GLXcontext *const gc = __glXGetCurrentContext();
3018 const GLuint cmdlen = 8;
3019 emit_header(gc->pc, X_GLrop_PushName, cmdlen);
3020 (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
3021 gc->pc += cmdlen;
3022 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3023 (void) __glXFlushRenderBuffer(gc, gc->pc);
3024 }
3025 }
3026
3027 #define X_GLrop_DrawBuffer 126
3028 void
3029 __indirect_glDrawBuffer(GLenum mode)
3030 {
3031 __GLXcontext *const gc = __glXGetCurrentContext();
3032 const GLuint cmdlen = 8;
3033 emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
3034 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3035 gc->pc += cmdlen;
3036 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3037 (void) __glXFlushRenderBuffer(gc, gc->pc);
3038 }
3039 }
3040
3041 #define X_GLrop_Clear 127
3042 void
3043 __indirect_glClear(GLbitfield mask)
3044 {
3045 __GLXcontext *const gc = __glXGetCurrentContext();
3046 const GLuint cmdlen = 8;
3047 emit_header(gc->pc, X_GLrop_Clear, cmdlen);
3048 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3049 gc->pc += cmdlen;
3050 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3051 (void) __glXFlushRenderBuffer(gc, gc->pc);
3052 }
3053 }
3054
3055 #define X_GLrop_ClearAccum 128
3056 void
3057 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue,
3058 GLfloat alpha)
3059 {
3060 __GLXcontext *const gc = __glXGetCurrentContext();
3061 const GLuint cmdlen = 20;
3062 emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
3063 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
3064 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
3065 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
3066 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
3067 gc->pc += cmdlen;
3068 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3069 (void) __glXFlushRenderBuffer(gc, gc->pc);
3070 }
3071 }
3072
3073 #define X_GLrop_ClearIndex 129
3074 void
3075 __indirect_glClearIndex(GLfloat c)
3076 {
3077 __GLXcontext *const gc = __glXGetCurrentContext();
3078 const GLuint cmdlen = 8;
3079 emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
3080 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
3081 gc->pc += cmdlen;
3082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3083 (void) __glXFlushRenderBuffer(gc, gc->pc);
3084 }
3085 }
3086
3087 #define X_GLrop_ClearColor 130
3088 void
3089 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
3090 GLclampf alpha)
3091 {
3092 __GLXcontext *const gc = __glXGetCurrentContext();
3093 const GLuint cmdlen = 20;
3094 emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
3095 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
3096 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
3097 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
3098 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
3099 gc->pc += cmdlen;
3100 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3101 (void) __glXFlushRenderBuffer(gc, gc->pc);
3102 }
3103 }
3104
3105 #define X_GLrop_ClearStencil 131
3106 void
3107 __indirect_glClearStencil(GLint s)
3108 {
3109 __GLXcontext *const gc = __glXGetCurrentContext();
3110 const GLuint cmdlen = 8;
3111 emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
3112 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
3113 gc->pc += cmdlen;
3114 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3115 (void) __glXFlushRenderBuffer(gc, gc->pc);
3116 }
3117 }
3118
3119 #define X_GLrop_ClearDepth 132
3120 void
3121 __indirect_glClearDepth(GLclampd depth)
3122 {
3123 __GLXcontext *const gc = __glXGetCurrentContext();
3124 const GLuint cmdlen = 12;
3125 emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
3126 (void) memcpy((void *) (gc->pc + 4), (void *) (&depth), 8);
3127 gc->pc += cmdlen;
3128 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3129 (void) __glXFlushRenderBuffer(gc, gc->pc);
3130 }
3131 }
3132
3133 #define X_GLrop_StencilMask 133
3134 void
3135 __indirect_glStencilMask(GLuint mask)
3136 {
3137 __GLXcontext *const gc = __glXGetCurrentContext();
3138 const GLuint cmdlen = 8;
3139 emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
3140 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3141 gc->pc += cmdlen;
3142 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3143 (void) __glXFlushRenderBuffer(gc, gc->pc);
3144 }
3145 }
3146
3147 #define X_GLrop_ColorMask 134
3148 void
3149 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
3150 GLboolean alpha)
3151 {
3152 __GLXcontext *const gc = __glXGetCurrentContext();
3153 const GLuint cmdlen = 8;
3154 emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
3155 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
3156 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
3157 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
3158 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
3159 gc->pc += cmdlen;
3160 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3161 (void) __glXFlushRenderBuffer(gc, gc->pc);
3162 }
3163 }
3164
3165 #define X_GLrop_DepthMask 135
3166 void
3167 __indirect_glDepthMask(GLboolean flag)
3168 {
3169 __GLXcontext *const gc = __glXGetCurrentContext();
3170 const GLuint cmdlen = 8;
3171 emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
3172 (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
3173 gc->pc += cmdlen;
3174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3175 (void) __glXFlushRenderBuffer(gc, gc->pc);
3176 }
3177 }
3178
3179 #define X_GLrop_IndexMask 136
3180 void
3181 __indirect_glIndexMask(GLuint mask)
3182 {
3183 __GLXcontext *const gc = __glXGetCurrentContext();
3184 const GLuint cmdlen = 8;
3185 emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
3186 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3187 gc->pc += cmdlen;
3188 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3189 (void) __glXFlushRenderBuffer(gc, gc->pc);
3190 }
3191 }
3192
3193 #define X_GLrop_Accum 137
3194 void
3195 __indirect_glAccum(GLenum op, GLfloat value)
3196 {
3197 __GLXcontext *const gc = __glXGetCurrentContext();
3198 const GLuint cmdlen = 12;
3199 emit_header(gc->pc, X_GLrop_Accum, cmdlen);
3200 (void) memcpy((void *) (gc->pc + 4), (void *) (&op), 4);
3201 (void) memcpy((void *) (gc->pc + 8), (void *) (&value), 4);
3202 gc->pc += cmdlen;
3203 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3204 (void) __glXFlushRenderBuffer(gc, gc->pc);
3205 }
3206 }
3207
3208 #define X_GLrop_PopAttrib 141
3209 void
3210 __indirect_glPopAttrib(void)
3211 {
3212 __GLXcontext *const gc = __glXGetCurrentContext();
3213 const GLuint cmdlen = 4;
3214 emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
3215 gc->pc += cmdlen;
3216 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3217 (void) __glXFlushRenderBuffer(gc, gc->pc);
3218 }
3219 }
3220
3221 #define X_GLrop_PushAttrib 142
3222 void
3223 __indirect_glPushAttrib(GLbitfield mask)
3224 {
3225 __GLXcontext *const gc = __glXGetCurrentContext();
3226 const GLuint cmdlen = 8;
3227 emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
3228 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3229 gc->pc += cmdlen;
3230 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3231 (void) __glXFlushRenderBuffer(gc, gc->pc);
3232 }
3233 }
3234
3235 #define X_GLrop_MapGrid1d 147
3236 void
3237 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
3238 {
3239 __GLXcontext *const gc = __glXGetCurrentContext();
3240 const GLuint cmdlen = 24;
3241 emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
3242 (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
3243 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
3244 (void) memcpy((void *) (gc->pc + 20), (void *) (&un), 4);
3245 gc->pc += cmdlen;
3246 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3247 (void) __glXFlushRenderBuffer(gc, gc->pc);
3248 }
3249 }
3250
3251 #define X_GLrop_MapGrid1f 148
3252 void
3253 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
3254 {
3255 __GLXcontext *const gc = __glXGetCurrentContext();
3256 const GLuint cmdlen = 16;
3257 emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
3258 (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
3259 (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
3260 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
3261 gc->pc += cmdlen;
3262 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3263 (void) __glXFlushRenderBuffer(gc, gc->pc);
3264 }
3265 }
3266
3267 #define X_GLrop_MapGrid2d 149
3268 void
3269 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn,
3270 GLdouble v1, GLdouble v2)
3271 {
3272 __GLXcontext *const gc = __glXGetCurrentContext();
3273 const GLuint cmdlen = 44;
3274 emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
3275 (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
3276 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
3277 (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 8);
3278 (void) memcpy((void *) (gc->pc + 28), (void *) (&v2), 8);
3279 (void) memcpy((void *) (gc->pc + 36), (void *) (&un), 4);
3280 (void) memcpy((void *) (gc->pc + 40), (void *) (&vn), 4);
3281 gc->pc += cmdlen;
3282 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3283 (void) __glXFlushRenderBuffer(gc, gc->pc);
3284 }
3285 }
3286
3287 #define X_GLrop_MapGrid2f 150
3288 void
3289 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1,
3290 GLfloat v2)
3291 {
3292 __GLXcontext *const gc = __glXGetCurrentContext();
3293 const GLuint cmdlen = 28;
3294 emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
3295 (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
3296 (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
3297 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
3298 (void) memcpy((void *) (gc->pc + 16), (void *) (&vn), 4);
3299 (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 4);
3300 (void) memcpy((void *) (gc->pc + 24), (void *) (&v2), 4);
3301 gc->pc += cmdlen;
3302 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3303 (void) __glXFlushRenderBuffer(gc, gc->pc);
3304 }
3305 }
3306
3307 #define X_GLrop_EvalCoord1dv 151
3308 void
3309 __indirect_glEvalCoord1d(GLdouble u)
3310 {
3311 __GLXcontext *const gc = __glXGetCurrentContext();
3312 const GLuint cmdlen = 12;
3313 emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
3314 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
3315 gc->pc += cmdlen;
3316 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3317 (void) __glXFlushRenderBuffer(gc, gc->pc);
3318 }
3319 }
3320
3321 #define X_GLrop_EvalCoord1dv 151
3322 void
3323 __indirect_glEvalCoord1dv(const GLdouble * u)
3324 {
3325 generic_8_byte(X_GLrop_EvalCoord1dv, u);
3326 }
3327
3328 #define X_GLrop_EvalCoord1fv 152
3329 void
3330 __indirect_glEvalCoord1f(GLfloat u)
3331 {
3332 __GLXcontext *const gc = __glXGetCurrentContext();
3333 const GLuint cmdlen = 8;
3334 emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
3335 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
3336 gc->pc += cmdlen;
3337 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3338 (void) __glXFlushRenderBuffer(gc, gc->pc);
3339 }
3340 }
3341
3342 #define X_GLrop_EvalCoord1fv 152
3343 void
3344 __indirect_glEvalCoord1fv(const GLfloat * u)
3345 {
3346 generic_4_byte(X_GLrop_EvalCoord1fv, u);
3347 }
3348
3349 #define X_GLrop_EvalCoord2dv 153
3350 void
3351 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
3352 {
3353 __GLXcontext *const gc = __glXGetCurrentContext();
3354 const GLuint cmdlen = 20;
3355 emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
3356 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
3357 (void) memcpy((void *) (gc->pc + 12), (void *) (&v), 8);
3358 gc->pc += cmdlen;
3359 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3360 (void) __glXFlushRenderBuffer(gc, gc->pc);
3361 }
3362 }
3363
3364 #define X_GLrop_EvalCoord2dv 153
3365 void
3366 __indirect_glEvalCoord2dv(const GLdouble * u)
3367 {
3368 generic_16_byte(X_GLrop_EvalCoord2dv, u);
3369 }
3370
3371 #define X_GLrop_EvalCoord2fv 154
3372 void
3373 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
3374 {
3375 __GLXcontext *const gc = __glXGetCurrentContext();
3376 const GLuint cmdlen = 12;
3377 emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
3378 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
3379 (void) memcpy((void *) (gc->pc + 8), (void *) (&v), 4);
3380 gc->pc += cmdlen;
3381 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3382 (void) __glXFlushRenderBuffer(gc, gc->pc);
3383 }
3384 }
3385
3386 #define X_GLrop_EvalCoord2fv 154
3387 void
3388 __indirect_glEvalCoord2fv(const GLfloat * u)
3389 {
3390 generic_8_byte(X_GLrop_EvalCoord2fv, u);
3391 }
3392
3393 #define X_GLrop_EvalMesh1 155
3394 void
3395 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
3396 {
3397 __GLXcontext *const gc = __glXGetCurrentContext();
3398 const GLuint cmdlen = 16;
3399 emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
3400 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3401 (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
3402 (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
3403 gc->pc += cmdlen;
3404 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3405 (void) __glXFlushRenderBuffer(gc, gc->pc);
3406 }
3407 }
3408
3409 #define X_GLrop_EvalPoint1 156
3410 void
3411 __indirect_glEvalPoint1(GLint i)
3412 {
3413 __GLXcontext *const gc = __glXGetCurrentContext();
3414 const GLuint cmdlen = 8;
3415 emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
3416 (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
3417 gc->pc += cmdlen;
3418 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3419 (void) __glXFlushRenderBuffer(gc, gc->pc);
3420 }
3421 }
3422
3423 #define X_GLrop_EvalMesh2 157
3424 void
3425 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
3426 {
3427 __GLXcontext *const gc = __glXGetCurrentContext();
3428 const GLuint cmdlen = 24;
3429 emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
3430 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3431 (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
3432 (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
3433 (void) memcpy((void *) (gc->pc + 16), (void *) (&j1), 4);
3434 (void) memcpy((void *) (gc->pc + 20), (void *) (&j2), 4);
3435 gc->pc += cmdlen;
3436 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3437 (void) __glXFlushRenderBuffer(gc, gc->pc);
3438 }
3439 }
3440
3441 #define X_GLrop_EvalPoint2 158
3442 void
3443 __indirect_glEvalPoint2(GLint i, GLint j)
3444 {
3445 __GLXcontext *const gc = __glXGetCurrentContext();
3446 const GLuint cmdlen = 12;
3447 emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
3448 (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
3449 (void) memcpy((void *) (gc->pc + 8), (void *) (&j), 4);
3450 gc->pc += cmdlen;
3451 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3452 (void) __glXFlushRenderBuffer(gc, gc->pc);
3453 }
3454 }
3455
3456 #define X_GLrop_AlphaFunc 159
3457 void
3458 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
3459 {
3460 __GLXcontext *const gc = __glXGetCurrentContext();
3461 const GLuint cmdlen = 12;
3462 emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
3463 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3464 (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
3465 gc->pc += cmdlen;
3466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3467 (void) __glXFlushRenderBuffer(gc, gc->pc);
3468 }
3469 }
3470
3471 #define X_GLrop_BlendFunc 160
3472 void
3473 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
3474 {
3475 __GLXcontext *const gc = __glXGetCurrentContext();
3476 const GLuint cmdlen = 12;
3477 emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
3478 (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactor), 4);
3479 (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactor), 4);
3480 gc->pc += cmdlen;
3481 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3482 (void) __glXFlushRenderBuffer(gc, gc->pc);
3483 }
3484 }
3485
3486 #define X_GLrop_LogicOp 161
3487 void
3488 __indirect_glLogicOp(GLenum opcode)
3489 {
3490 __GLXcontext *const gc = __glXGetCurrentContext();
3491 const GLuint cmdlen = 8;
3492 emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
3493 (void) memcpy((void *) (gc->pc + 4), (void *) (&opcode), 4);
3494 gc->pc += cmdlen;
3495 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3496 (void) __glXFlushRenderBuffer(gc, gc->pc);
3497 }
3498 }
3499
3500 #define X_GLrop_StencilFunc 162
3501 void
3502 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3503 {
3504 __GLXcontext *const gc = __glXGetCurrentContext();
3505 const GLuint cmdlen = 16;
3506 emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
3507 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3508 (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
3509 (void) memcpy((void *) (gc->pc + 12), (void *) (&mask), 4);
3510 gc->pc += cmdlen;
3511 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3512 (void) __glXFlushRenderBuffer(gc, gc->pc);
3513 }
3514 }
3515
3516 #define X_GLrop_StencilOp 163
3517 void
3518 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3519 {
3520 __GLXcontext *const gc = __glXGetCurrentContext();
3521 const GLuint cmdlen = 16;
3522 emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
3523 (void) memcpy((void *) (gc->pc + 4), (void *) (&fail), 4);
3524 (void) memcpy((void *) (gc->pc + 8), (void *) (&zfail), 4);
3525 (void) memcpy((void *) (gc->pc + 12), (void *) (&zpass), 4);
3526 gc->pc += cmdlen;
3527 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3528 (void) __glXFlushRenderBuffer(gc, gc->pc);
3529 }
3530 }
3531
3532 #define X_GLrop_DepthFunc 164
3533 void
3534 __indirect_glDepthFunc(GLenum func)
3535 {
3536 __GLXcontext *const gc = __glXGetCurrentContext();
3537 const GLuint cmdlen = 8;
3538 emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
3539 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3540 gc->pc += cmdlen;
3541 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3542 (void) __glXFlushRenderBuffer(gc, gc->pc);
3543 }
3544 }
3545
3546 #define X_GLrop_PixelZoom 165
3547 void
3548 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
3549 {
3550 __GLXcontext *const gc = __glXGetCurrentContext();
3551 const GLuint cmdlen = 12;
3552 emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
3553 (void) memcpy((void *) (gc->pc + 4), (void *) (&xfactor), 4);
3554 (void) memcpy((void *) (gc->pc + 8), (void *) (&yfactor), 4);
3555 gc->pc += cmdlen;
3556 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3557 (void) __glXFlushRenderBuffer(gc, gc->pc);
3558 }
3559 }
3560
3561 #define X_GLrop_PixelTransferf 166
3562 void
3563 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
3564 {
3565 __GLXcontext *const gc = __glXGetCurrentContext();
3566 const GLuint cmdlen = 12;
3567 emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
3568 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
3569 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
3570 gc->pc += cmdlen;
3571 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3572 (void) __glXFlushRenderBuffer(gc, gc->pc);
3573 }
3574 }
3575
3576 #define X_GLrop_PixelTransferi 167
3577 void
3578 __indirect_glPixelTransferi(GLenum pname, GLint param)
3579 {
3580 __GLXcontext *const gc = __glXGetCurrentContext();
3581 const GLuint cmdlen = 12;
3582 emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
3583 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
3584 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
3585 gc->pc += cmdlen;
3586 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3587 (void) __glXFlushRenderBuffer(gc, gc->pc);
3588 }
3589 }
3590
3591 #define X_GLrop_PixelMapfv 168
3592 void
3593 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
3594 {
3595 __GLXcontext *const gc = __glXGetCurrentContext();
3596 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3597 if (mapsize < 0) {
3598 __glXSetError(gc, GL_INVALID_VALUE);
3599 return;
3600 }
3601 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3602 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3603 if ((gc->pc + cmdlen) > gc->bufEnd) {
3604 (void) __glXFlushRenderBuffer(gc, gc->pc);
3605 }
3606 emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
3607 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3608 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3609 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3610 (mapsize * 4));
3611 gc->pc += cmdlen;
3612 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3613 (void) __glXFlushRenderBuffer(gc, gc->pc);
3614 }
3615 } else {
3616 const GLint op = X_GLrop_PixelMapfv;
3617 const GLuint cmdlenLarge = cmdlen + 4;
3618 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3619 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3620 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3621 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3622 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3623 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3624 }
3625 }
3626 }
3627
3628 #define X_GLrop_PixelMapuiv 169
3629 void
3630 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3631 {
3632 __GLXcontext *const gc = __glXGetCurrentContext();
3633 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3634 if (mapsize < 0) {
3635 __glXSetError(gc, GL_INVALID_VALUE);
3636 return;
3637 }
3638 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3639 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3640 if ((gc->pc + cmdlen) > gc->bufEnd) {
3641 (void) __glXFlushRenderBuffer(gc, gc->pc);
3642 }
3643 emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3644 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3645 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3646 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3647 (mapsize * 4));
3648 gc->pc += cmdlen;
3649 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3650 (void) __glXFlushRenderBuffer(gc, gc->pc);
3651 }
3652 } else {
3653 const GLint op = X_GLrop_PixelMapuiv;
3654 const GLuint cmdlenLarge = cmdlen + 4;
3655 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3656 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3657 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3658 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3659 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3660 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3661 }
3662 }
3663 }
3664
3665 #define X_GLrop_PixelMapusv 170
3666 void
3667 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3668 {
3669 __GLXcontext *const gc = __glXGetCurrentContext();
3670 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3671 if (mapsize < 0) {
3672 __glXSetError(gc, GL_INVALID_VALUE);
3673 return;
3674 }
3675 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3676 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3677 if ((gc->pc + cmdlen) > gc->bufEnd) {
3678 (void) __glXFlushRenderBuffer(gc, gc->pc);
3679 }
3680 emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3681 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3682 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3683 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3684 (mapsize * 2));
3685 gc->pc += cmdlen;
3686 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3687 (void) __glXFlushRenderBuffer(gc, gc->pc);
3688 }
3689 } else {
3690 const GLint op = X_GLrop_PixelMapusv;
3691 const GLuint cmdlenLarge = cmdlen + 4;
3692 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3693 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3694 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3695 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3696 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3697 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
3698 }
3699 }
3700 }
3701
3702 #define X_GLrop_ReadBuffer 171
3703 void
3704 __indirect_glReadBuffer(GLenum mode)
3705 {
3706 __GLXcontext *const gc = __glXGetCurrentContext();
3707 const GLuint cmdlen = 8;
3708 emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3709 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3710 gc->pc += cmdlen;
3711 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3712 (void) __glXFlushRenderBuffer(gc, gc->pc);
3713 }
3714 }
3715
3716 #define X_GLrop_CopyPixels 172
3717 void
3718 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3719 GLenum type)
3720 {
3721 __GLXcontext *const gc = __glXGetCurrentContext();
3722 const GLuint cmdlen = 24;
3723 emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3724 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
3725 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
3726 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
3727 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
3728 (void) memcpy((void *) (gc->pc + 20), (void *) (&type), 4);
3729 gc->pc += cmdlen;
3730 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3731 (void) __glXFlushRenderBuffer(gc, gc->pc);
3732 }
3733 }
3734
3735 #define X_GLsop_ReadPixels 111
3736 void
3737 __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3738 GLenum format, GLenum type, GLvoid * pixels)
3739 {
3740 __GLXcontext *const gc = __glXGetCurrentContext();
3741 const __GLXattribute *const state = gc->client_state_private;
3742 Display *const dpy = gc->currentDpy;
3743 #ifndef USE_XCB
3744 const GLuint cmdlen = 28;
3745 #endif
3746 if (__builtin_expect(dpy != NULL, 1)) {
3747 #ifdef USE_XCB
3748 xcb_connection_t *c = XGetXCBConnection(dpy);
3749 (void) __glXFlushRenderBuffer(gc, gc->pc);
3750 xcb_glx_read_pixels_reply_t *reply =
3751 xcb_glx_read_pixels_reply(c,
3752 xcb_glx_read_pixels(c,
3753 gc->
3754 currentContextTag,
3755 x, y, width, height,
3756 format, type,
3757 state->storePack.
3758 swapEndian, 0),
3759 NULL);
3760 (void) memcpy(pixels, xcb_glx_read_pixels_data(reply),
3761 xcb_glx_read_pixels_data_length(reply) *
3762 sizeof(GLvoid));
3763 free(reply);
3764 #else
3765 GLubyte const *pc =
3766 __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
3767 (void) memcpy((void *) (pc + 0), (void *) (&x), 4);
3768 (void) memcpy((void *) (pc + 4), (void *) (&y), 4);
3769 (void) memcpy((void *) (pc + 8), (void *) (&width), 4);
3770 (void) memcpy((void *) (pc + 12), (void *) (&height), 4);
3771 (void) memcpy((void *) (pc + 16), (void *) (&format), 4);
3772 (void) memcpy((void *) (pc + 20), (void *) (&type), 4);
3773 *(int32_t *) (pc + 24) = 0;
3774 *(int8_t *) (pc + 24) = state->storePack.swapEndian;
3775 __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type,
3776 pixels, GL_FALSE);
3777 UnlockDisplay(dpy);
3778 SyncHandle();
3779 #endif /* USE_XCB */
3780 }
3781 return;
3782 }
3783
3784 #define X_GLrop_DrawPixels 173
3785 void
3786 __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format,
3787 GLenum type, const GLvoid * pixels)
3788 {
3789 __GLXcontext *const gc = __glXGetCurrentContext();
3790 const GLuint compsize =
3791 (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
3792 0) : 0;
3793 const GLuint cmdlen = 40 + __GLX_PAD(compsize);
3794 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
3795 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3796 if ((gc->pc + cmdlen) > gc->bufEnd) {
3797 (void) __glXFlushRenderBuffer(gc, gc->pc);
3798 }
3799 emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
3800 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
3801 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
3802 (void) memcpy((void *) (gc->pc + 32), (void *) (&format), 4);
3803 (void) memcpy((void *) (gc->pc + 36), (void *) (&type), 4);
3804 if (compsize > 0) {
3805 (*gc->fillImage) (gc, 2, width, height, 1, format, type,
3806 pixels, gc->pc + 40, gc->pc + 4);
3807 } else {
3808 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
3809 default_pixel_store_2D_size);
3810 }
3811 gc->pc += cmdlen;
3812 if (gc->pc > gc->limit) {
3813 (void) __glXFlushRenderBuffer(gc, gc->pc);
3814 }
3815 } else {
3816 const GLint op = X_GLrop_DrawPixels;
3817 const GLuint cmdlenLarge = cmdlen + 4;
3818 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3819 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3820 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3821 (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
3822 (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
3823 (void) memcpy((void *) (pc + 36), (void *) (&format), 4);
3824 (void) memcpy((void *) (pc + 40), (void *) (&type), 4);
3825 __glXSendLargeImage(gc, compsize, 2, width, height, 1, format,
3826 type, pixels, pc + 44, pc + 8);
3827 }
3828 }
3829 }
3830
3831 #define X_GLsop_GetClipPlane 113
3832 void
3833 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3834 {
3835 __GLXcontext *const gc = __glXGetCurrentContext();
3836 Display *const dpy = gc->currentDpy;
3837 #ifndef USE_XCB
3838 const GLuint cmdlen = 4;
3839 #endif
3840 if (__builtin_expect(dpy != NULL, 1)) {
3841 #ifdef USE_XCB
3842 xcb_connection_t *c = XGetXCBConnection(dpy);
3843 (void) __glXFlushRenderBuffer(gc, gc->pc);
3844 xcb_glx_get_clip_plane_reply_t *reply =
3845 xcb_glx_get_clip_plane_reply(c,
3846 xcb_glx_get_clip_plane(c,
3847 gc->
3848 currentContextTag,
3849 plane), NULL);
3850 (void) memcpy(equation, xcb_glx_get_clip_plane_data(reply),
3851 xcb_glx_get_clip_plane_data_length(reply) *
3852 sizeof(GLdouble));
3853 free(reply);
3854 #else
3855 GLubyte const *pc =
3856 __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
3857 (void) memcpy((void *) (pc + 0), (void *) (&plane), 4);
3858 (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
3859 UnlockDisplay(dpy);
3860 SyncHandle();
3861 #endif /* USE_XCB */
3862 }
3863 return;
3864 }
3865
3866 #define X_GLsop_GetLightfv 118
3867 void
3868 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3869 {
3870 __GLXcontext *const gc = __glXGetCurrentContext();
3871 Display *const dpy = gc->currentDpy;
3872 #ifndef USE_XCB
3873 const GLuint cmdlen = 8;
3874 #endif
3875 if (__builtin_expect(dpy != NULL, 1)) {
3876 #ifdef USE_XCB
3877 xcb_connection_t *c = XGetXCBConnection(dpy);
3878 (void) __glXFlushRenderBuffer(gc, gc->pc);
3879 xcb_glx_get_lightfv_reply_t *reply =
3880 xcb_glx_get_lightfv_reply(c,
3881 xcb_glx_get_lightfv(c,
3882 gc->
3883 currentContextTag,
3884 light, pname),
3885 NULL);
3886 if (xcb_glx_get_lightfv_data_length(reply) == 0)
3887 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
3888 else
3889 (void) memcpy(params, xcb_glx_get_lightfv_data(reply),
3890 xcb_glx_get_lightfv_data_length(reply) *
3891 sizeof(GLfloat));
3892 free(reply);
3893 #else
3894 GLubyte const *pc =
3895 __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
3896 (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
3897 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
3898 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3899 UnlockDisplay(dpy);
3900 SyncHandle();
3901 #endif /* USE_XCB */
3902 }
3903 return;
3904 }
3905
3906 #define X_GLsop_GetLightiv 119
3907 void
3908 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3909 {
3910 __GLXcontext *const gc = __glXGetCurrentContext();
3911 Display *const dpy = gc->currentDpy;
3912 #ifndef USE_XCB
3913 const GLuint cmdlen = 8;
3914 #endif
3915 if (__builtin_expect(dpy != NULL, 1)) {
3916 #ifdef USE_XCB
3917 xcb_connection_t *c = XGetXCBConnection(dpy);
3918 (void) __glXFlushRenderBuffer(gc, gc->pc);
3919 xcb_glx_get_lightiv_reply_t *reply =
3920 xcb_glx_get_lightiv_reply(c,
3921 xcb_glx_get_lightiv(c,
3922 gc->
3923 currentContextTag,
3924 light, pname),
3925 NULL);
3926 if (xcb_glx_get_lightiv_data_length(reply) == 0)
3927 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
3928 else
3929 (void) memcpy(params, xcb_glx_get_lightiv_data(reply),
3930 xcb_glx_get_lightiv_data_length(reply) *
3931 sizeof(GLint));
3932 free(reply);
3933 #else
3934 GLubyte const *pc =
3935 __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
3936 (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
3937 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
3938 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3939 UnlockDisplay(dpy);
3940 SyncHandle();
3941 #endif /* USE_XCB */
3942 }
3943 return;
3944 }
3945
3946 #define X_GLsop_GetMapdv 120
3947 void
3948 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3949 {
3950 __GLXcontext *const gc = __glXGetCurrentContext();
3951 Display *const dpy = gc->currentDpy;
3952 #ifndef USE_XCB
3953 const GLuint cmdlen = 8;
3954 #endif
3955 if (__builtin_expect(dpy != NULL, 1)) {
3956 #ifdef USE_XCB
3957 xcb_connection_t *c = XGetXCBConnection(dpy);
3958 (void) __glXFlushRenderBuffer(gc, gc->pc);
3959 xcb_glx_get_mapdv_reply_t *reply =
3960 xcb_glx_get_mapdv_reply(c,
3961 xcb_glx_get_mapdv(c,
3962 gc->currentContextTag,
3963 target, query), NULL);
3964 if (xcb_glx_get_mapdv_data_length(reply) == 0)
3965 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
3966 else
3967 (void) memcpy(v, xcb_glx_get_mapdv_data(reply),
3968 xcb_glx_get_mapdv_data_length(reply) *
3969 sizeof(GLdouble));
3970 free(reply);
3971 #else
3972 GLubyte const *pc =
3973 __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
3974 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
3975 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
3976 (void) __glXReadReply(dpy, 8, v, GL_FALSE);
3977 UnlockDisplay(dpy);
3978 SyncHandle();
3979 #endif /* USE_XCB */
3980 }
3981 return;
3982 }
3983
3984 #define X_GLsop_GetMapfv 121
3985 void
3986 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3987 {
3988 __GLXcontext *const gc = __glXGetCurrentContext();
3989 Display *const dpy = gc->currentDpy;
3990 #ifndef USE_XCB
3991 const GLuint cmdlen = 8;
3992 #endif
3993 if (__builtin_expect(dpy != NULL, 1)) {
3994 #ifdef USE_XCB
3995 xcb_connection_t *c = XGetXCBConnection(dpy);
3996 (void) __glXFlushRenderBuffer(gc, gc->pc);
3997 xcb_glx_get_mapfv_reply_t *reply =
3998 xcb_glx_get_mapfv_reply(c,
3999 xcb_glx_get_mapfv(c,
4000 gc->currentContextTag,
4001 target, query), NULL);
4002 if (xcb_glx_get_mapfv_data_length(reply) == 0)
4003 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
4004 else
4005 (void) memcpy(v, xcb_glx_get_mapfv_data(reply),
4006 xcb_glx_get_mapfv_data_length(reply) *
4007 sizeof(GLfloat));
4008 free(reply);
4009 #else
4010 GLubyte const *pc =
4011 __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
4012 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4013 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
4014 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
4015 UnlockDisplay(dpy);
4016 SyncHandle();
4017 #endif /* USE_XCB */
4018 }
4019 return;
4020 }
4021
4022 #define X_GLsop_GetMapiv 122
4023 void
4024 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
4025 {
4026 __GLXcontext *const gc = __glXGetCurrentContext();
4027 Display *const dpy = gc->currentDpy;
4028 #ifndef USE_XCB
4029 const GLuint cmdlen = 8;
4030 #endif
4031 if (__builtin_expect(dpy != NULL, 1)) {
4032 #ifdef USE_XCB
4033 xcb_connection_t *c = XGetXCBConnection(dpy);
4034 (void) __glXFlushRenderBuffer(gc, gc->pc);
4035 xcb_glx_get_mapiv_reply_t *reply =
4036 xcb_glx_get_mapiv_reply(c,
4037 xcb_glx_get_mapiv(c,
4038 gc->currentContextTag,
4039 target, query), NULL);
4040 if (xcb_glx_get_mapiv_data_length(reply) == 0)
4041 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
4042 else
4043 (void) memcpy(v, xcb_glx_get_mapiv_data(reply),
4044 xcb_glx_get_mapiv_data_length(reply) *
4045 sizeof(GLint));
4046 free(reply);
4047 #else
4048 GLubyte const *pc =
4049 __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
4050 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4051 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
4052 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
4053 UnlockDisplay(dpy);
4054 SyncHandle();
4055 #endif /* USE_XCB */
4056 }
4057 return;
4058 }
4059
4060 #define X_GLsop_GetMaterialfv 123
4061 void
4062 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
4063 {
4064 __GLXcontext *const gc = __glXGetCurrentContext();
4065 Display *const dpy = gc->currentDpy;
4066 #ifndef USE_XCB
4067 const GLuint cmdlen = 8;
4068 #endif
4069 if (__builtin_expect(dpy != NULL, 1)) {
4070 #ifdef USE_XCB
4071 xcb_connection_t *c = XGetXCBConnection(dpy);
4072 (void) __glXFlushRenderBuffer(gc, gc->pc);
4073 xcb_glx_get_materialfv_reply_t *reply =
4074 xcb_glx_get_materialfv_reply(c,
4075 xcb_glx_get_materialfv(c,
4076 gc->
4077 currentContextTag,
4078 face, pname),
4079 NULL);
4080 if (xcb_glx_get_materialfv_data_length(reply) == 0)
4081 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4082 else
4083 (void) memcpy(params, xcb_glx_get_materialfv_data(reply),
4084 xcb_glx_get_materialfv_data_length(reply) *
4085 sizeof(GLfloat));
4086 free(reply);
4087 #else
4088 GLubyte const *pc =
4089 __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
4090 (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
4091 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4092 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4093 UnlockDisplay(dpy);
4094 SyncHandle();
4095 #endif /* USE_XCB */
4096 }
4097 return;
4098 }
4099
4100 #define X_GLsop_GetMaterialiv 124
4101 void
4102 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
4103 {
4104 __GLXcontext *const gc = __glXGetCurrentContext();
4105 Display *const dpy = gc->currentDpy;
4106 #ifndef USE_XCB
4107 const GLuint cmdlen = 8;
4108 #endif
4109 if (__builtin_expect(dpy != NULL, 1)) {
4110 #ifdef USE_XCB
4111 xcb_connection_t *c = XGetXCBConnection(dpy);
4112 (void) __glXFlushRenderBuffer(gc, gc->pc);
4113 xcb_glx_get_materialiv_reply_t *reply =
4114 xcb_glx_get_materialiv_reply(c,
4115 xcb_glx_get_materialiv(c,
4116 gc->
4117 currentContextTag,
4118 face, pname),
4119 NULL);
4120 if (xcb_glx_get_materialiv_data_length(reply) == 0)
4121 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4122 else
4123 (void) memcpy(params, xcb_glx_get_materialiv_data(reply),
4124 xcb_glx_get_materialiv_data_length(reply) *
4125 sizeof(GLint));
4126 free(reply);
4127 #else
4128 GLubyte const *pc =
4129 __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
4130 (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
4131 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4132 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4133 UnlockDisplay(dpy);
4134 SyncHandle();
4135 #endif /* USE_XCB */
4136 }
4137 return;
4138 }
4139
4140 #define X_GLsop_GetPixelMapfv 125
4141 void
4142 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
4143 {
4144 __GLXcontext *const gc = __glXGetCurrentContext();
4145 Display *const dpy = gc->currentDpy;
4146 #ifndef USE_XCB
4147 const GLuint cmdlen = 4;
4148 #endif
4149 if (__builtin_expect(dpy != NULL, 1)) {
4150 #ifdef USE_XCB
4151 xcb_connection_t *c = XGetXCBConnection(dpy);
4152 (void) __glXFlushRenderBuffer(gc, gc->pc);
4153 xcb_glx_get_pixel_mapfv_reply_t *reply =
4154 xcb_glx_get_pixel_mapfv_reply(c,
4155 xcb_glx_get_pixel_mapfv(c,
4156 gc->
4157 currentContextTag,
4158 map), NULL);
4159 if (xcb_glx_get_pixel_mapfv_data_length(reply) == 0)
4160 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4161 else
4162 (void) memcpy(values, xcb_glx_get_pixel_mapfv_data(reply),
4163 xcb_glx_get_pixel_mapfv_data_length(reply) *
4164 sizeof(GLfloat));
4165 free(reply);
4166 #else
4167 GLubyte const *pc =
4168 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
4169 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4170 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
4171 UnlockDisplay(dpy);
4172 SyncHandle();
4173 #endif /* USE_XCB */
4174 }
4175 return;
4176 }
4177
4178 #define X_GLsop_GetPixelMapuiv 126
4179 void
4180 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
4181 {
4182 __GLXcontext *const gc = __glXGetCurrentContext();
4183 Display *const dpy = gc->currentDpy;
4184 #ifndef USE_XCB
4185 const GLuint cmdlen = 4;
4186 #endif
4187 if (__builtin_expect(dpy != NULL, 1)) {
4188 #ifdef USE_XCB
4189 xcb_connection_t *c = XGetXCBConnection(dpy);
4190 (void) __glXFlushRenderBuffer(gc, gc->pc);
4191 xcb_glx_get_pixel_mapuiv_reply_t *reply =
4192 xcb_glx_get_pixel_mapuiv_reply(c,
4193 xcb_glx_get_pixel_mapuiv(c,
4194 gc->
4195 currentContextTag,
4196 map),
4197 NULL);
4198 if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 0)
4199 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4200 else
4201 (void) memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply),
4202 xcb_glx_get_pixel_mapuiv_data_length(reply) *
4203 sizeof(GLuint));
4204 free(reply);
4205 #else
4206 GLubyte const *pc =
4207 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
4208 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4209 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
4210 UnlockDisplay(dpy);
4211 SyncHandle();
4212 #endif /* USE_XCB */
4213 }
4214 return;
4215 }
4216
4217 #define X_GLsop_GetPixelMapusv 127
4218 void
4219 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
4220 {
4221 __GLXcontext *const gc = __glXGetCurrentContext();
4222 Display *const dpy = gc->currentDpy;
4223 #ifndef USE_XCB
4224 const GLuint cmdlen = 4;
4225 #endif
4226 if (__builtin_expect(dpy != NULL, 1)) {
4227 #ifdef USE_XCB
4228 xcb_connection_t *c = XGetXCBConnection(dpy);
4229 (void) __glXFlushRenderBuffer(gc, gc->pc);
4230 xcb_glx_get_pixel_mapusv_reply_t *reply =
4231 xcb_glx_get_pixel_mapusv_reply(c,
4232 xcb_glx_get_pixel_mapusv(c,
4233 gc->
4234 currentContextTag,
4235 map),
4236 NULL);
4237 if (xcb_glx_get_pixel_mapusv_data_length(reply) == 0)
4238 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4239 else
4240 (void) memcpy(values, xcb_glx_get_pixel_mapusv_data(reply),
4241 xcb_glx_get_pixel_mapusv_data_length(reply) *
4242 sizeof(GLushort));
4243 free(reply);
4244 #else
4245 GLubyte const *pc =
4246 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
4247 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4248 (void) __glXReadReply(dpy, 2, values, GL_FALSE);
4249 UnlockDisplay(dpy);
4250 SyncHandle();
4251 #endif /* USE_XCB */
4252 }
4253 return;
4254 }
4255
4256 #define X_GLsop_GetPolygonStipple 128
4257 void
4258 __indirect_glGetPolygonStipple(GLubyte *mask)
4259 {
4260 __GLXcontext *const gc = __glXGetCurrentContext();
4261 Display *const dpy = gc->currentDpy;
4262 #ifndef USE_XCB
4263 const GLuint cmdlen = 4;
4264 #endif
4265 if (__builtin_expect(dpy != NULL, 1)) {
4266 #ifdef USE_XCB
4267 xcb_connection_t *c = XGetXCBConnection(dpy);
4268 (void) __glXFlushRenderBuffer(gc, gc->pc);
4269 xcb_glx_get_polygon_stipple_reply_t *reply =
4270 xcb_glx_get_polygon_stipple_reply(c,
4271 xcb_glx_get_polygon_stipple(c,
4272 gc->
4273 currentContextTag,
4274 0),
4275 NULL);
4276 (void) memcpy(mask, xcb_glx_get_polygon_stipple_data(reply),
4277 xcb_glx_get_polygon_stipple_data_length(reply) *
4278 sizeof(GLubyte));
4279 free(reply);
4280 #else
4281 GLubyte const *pc =
4282 __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
4283 *(int32_t *) (pc + 0) = 0;
4284 __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
4285 mask, GL_FALSE);
4286 UnlockDisplay(dpy);
4287 SyncHandle();
4288 #endif /* USE_XCB */
4289 }
4290 return;
4291 }
4292
4293 #define X_GLsop_GetTexEnvfv 130
4294 void
4295 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
4296 {
4297 __GLXcontext *const gc = __glXGetCurrentContext();
4298 Display *const dpy = gc->currentDpy;
4299 #ifndef USE_XCB
4300 const GLuint cmdlen = 8;
4301 #endif
4302 if (__builtin_expect(dpy != NULL, 1)) {
4303 #ifdef USE_XCB
4304 xcb_connection_t *c = XGetXCBConnection(dpy);
4305 (void) __glXFlushRenderBuffer(gc, gc->pc);
4306 xcb_glx_get_tex_envfv_reply_t *reply =
4307 xcb_glx_get_tex_envfv_reply(c,
4308 xcb_glx_get_tex_envfv(c,
4309 gc->
4310 currentContextTag,
4311 target, pname),
4312 NULL);
4313 if (xcb_glx_get_tex_envfv_data_length(reply) == 0)
4314 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4315 else
4316 (void) memcpy(params, xcb_glx_get_tex_envfv_data(reply),
4317 xcb_glx_get_tex_envfv_data_length(reply) *
4318 sizeof(GLfloat));
4319 free(reply);
4320 #else
4321 GLubyte const *pc =
4322 __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
4323 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4324 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4325 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4326 UnlockDisplay(dpy);
4327 SyncHandle();
4328 #endif /* USE_XCB */
4329 }
4330 return;
4331 }
4332
4333 #define X_GLsop_GetTexEnviv 131
4334 void
4335 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
4336 {
4337 __GLXcontext *const gc = __glXGetCurrentContext();
4338 Display *const dpy = gc->currentDpy;
4339 #ifndef USE_XCB
4340 const GLuint cmdlen = 8;
4341 #endif
4342 if (__builtin_expect(dpy != NULL, 1)) {
4343 #ifdef USE_XCB
4344 xcb_connection_t *c = XGetXCBConnection(dpy);
4345 (void) __glXFlushRenderBuffer(gc, gc->pc);
4346 xcb_glx_get_tex_enviv_reply_t *reply =
4347 xcb_glx_get_tex_enviv_reply(c,
4348 xcb_glx_get_tex_enviv(c,
4349 gc->
4350 currentContextTag,
4351 target, pname),
4352 NULL);
4353 if (xcb_glx_get_tex_enviv_data_length(reply) == 0)
4354 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4355 else
4356 (void) memcpy(params, xcb_glx_get_tex_enviv_data(reply),
4357 xcb_glx_get_tex_enviv_data_length(reply) *
4358 sizeof(GLint));
4359 free(reply);
4360 #else
4361 GLubyte const *pc =
4362 __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
4363 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4364 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4365 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4366 UnlockDisplay(dpy);
4367 SyncHandle();
4368 #endif /* USE_XCB */
4369 }
4370 return;
4371 }
4372
4373 #define X_GLsop_GetTexGendv 132
4374 void
4375 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
4376 {
4377 __GLXcontext *const gc = __glXGetCurrentContext();
4378 Display *const dpy = gc->currentDpy;
4379 #ifndef USE_XCB
4380 const GLuint cmdlen = 8;
4381 #endif
4382 if (__builtin_expect(dpy != NULL, 1)) {
4383 #ifdef USE_XCB
4384 xcb_connection_t *c = XGetXCBConnection(dpy);
4385 (void) __glXFlushRenderBuffer(gc, gc->pc);
4386 xcb_glx_get_tex_gendv_reply_t *reply =
4387 xcb_glx_get_tex_gendv_reply(c,
4388 xcb_glx_get_tex_gendv(c,
4389 gc->
4390 currentContextTag,
4391 coord, pname),
4392 NULL);
4393 if (xcb_glx_get_tex_gendv_data_length(reply) == 0)
4394 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4395 else
4396 (void) memcpy(params, xcb_glx_get_tex_gendv_data(reply),
4397 xcb_glx_get_tex_gendv_data_length(reply) *
4398 sizeof(GLdouble));
4399 free(reply);
4400 #else
4401 GLubyte const *pc =
4402 __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
4403 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4404 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4405 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
4406 UnlockDisplay(dpy);
4407 SyncHandle();
4408 #endif /* USE_XCB */
4409 }
4410 return;
4411 }
4412
4413 #define X_GLsop_GetTexGenfv 133
4414 void
4415 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
4416 {
4417 __GLXcontext *const gc = __glXGetCurrentContext();
4418 Display *const dpy = gc->currentDpy;
4419 #ifndef USE_XCB
4420 const GLuint cmdlen = 8;
4421 #endif
4422 if (__builtin_expect(dpy != NULL, 1)) {
4423 #ifdef USE_XCB
4424 xcb_connection_t *c = XGetXCBConnection(dpy);
4425 (void) __glXFlushRenderBuffer(gc, gc->pc);
4426 xcb_glx_get_tex_genfv_reply_t *reply =
4427 xcb_glx_get_tex_genfv_reply(c,
4428 xcb_glx_get_tex_genfv(c,
4429 gc->
4430 currentContextTag,
4431 coord, pname),
4432 NULL);
4433 if (xcb_glx_get_tex_genfv_data_length(reply) == 0)
4434 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4435 else
4436 (void) memcpy(params, xcb_glx_get_tex_genfv_data(reply),
4437 xcb_glx_get_tex_genfv_data_length(reply) *
4438 sizeof(GLfloat));
4439 free(reply);
4440 #else
4441 GLubyte const *pc =
4442 __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
4443 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4444 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4445 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4446 UnlockDisplay(dpy);
4447 SyncHandle();
4448 #endif /* USE_XCB */
4449 }
4450 return;
4451 }
4452
4453 #define X_GLsop_GetTexGeniv 134
4454 void
4455 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
4456 {
4457 __GLXcontext *const gc = __glXGetCurrentContext();
4458 Display *const dpy = gc->currentDpy;
4459 #ifndef USE_XCB
4460 const GLuint cmdlen = 8;
4461 #endif
4462 if (__builtin_expect(dpy != NULL, 1)) {
4463 #ifdef USE_XCB
4464 xcb_connection_t *c = XGetXCBConnection(dpy);
4465 (void) __glXFlushRenderBuffer(gc, gc->pc);
4466 xcb_glx_get_tex_geniv_reply_t *reply =
4467 xcb_glx_get_tex_geniv_reply(c,
4468 xcb_glx_get_tex_geniv(c,
4469 gc->
4470 currentContextTag,
4471 coord, pname),
4472 NULL);
4473 if (xcb_glx_get_tex_geniv_data_length(reply) == 0)
4474 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4475 else
4476 (void) memcpy(params, xcb_glx_get_tex_geniv_data(reply),
4477 xcb_glx_get_tex_geniv_data_length(reply) *
4478 sizeof(GLint));
4479 free(reply);
4480 #else
4481 GLubyte const *pc =
4482 __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
4483 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4484 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4485 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4486 UnlockDisplay(dpy);
4487 SyncHandle();
4488 #endif /* USE_XCB */
4489 }
4490 return;
4491 }
4492
4493 #define X_GLsop_GetTexImage 135
4494 void
4495 __indirect_glGetTexImage(GLenum target, GLint level, GLenum format,
4496 GLenum type, GLvoid * pixels)
4497 {
4498 __GLXcontext *const gc = __glXGetCurrentContext();
4499 const __GLXattribute *const state = gc->client_state_private;
4500 Display *const dpy = gc->currentDpy;
4501 #ifndef USE_XCB
4502 const GLuint cmdlen = 20;
4503 #endif
4504 if (__builtin_expect(dpy != NULL, 1)) {
4505 #ifdef USE_XCB
4506 xcb_connection_t *c = XGetXCBConnection(dpy);
4507 (void) __glXFlushRenderBuffer(gc, gc->pc);
4508 xcb_glx_get_tex_image_reply_t *reply =
4509 xcb_glx_get_tex_image_reply(c,
4510 xcb_glx_get_tex_image(c,
4511 gc->
4512 currentContextTag,
4513 target, level,
4514 format, type,
4515 state->
4516 storePack.
4517 swapEndian),
4518 NULL);
4519 (void) memcpy(pixels, xcb_glx_get_tex_image_data(reply),
4520 xcb_glx_get_tex_image_data_length(reply) *
4521 sizeof(GLvoid));
4522 free(reply);
4523 #else
4524 GLubyte const *pc =
4525 __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
4526 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4527 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4528 (void) memcpy((void *) (pc + 8), (void *) (&format), 4);
4529 (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
4530 *(int32_t *) (pc + 16) = 0;
4531 *(int8_t *) (pc + 16) = state->storePack.swapEndian;
4532 __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels,
4533 GL_TRUE);
4534 UnlockDisplay(dpy);
4535 SyncHandle();
4536 #endif /* USE_XCB */
4537 }
4538 return;
4539 }
4540
4541 #define X_GLsop_GetTexParameterfv 136
4542 void
4543 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
4544 {
4545 __GLXcontext *const gc = __glXGetCurrentContext();
4546 Display *const dpy = gc->currentDpy;
4547 #ifndef USE_XCB
4548 const GLuint cmdlen = 8;
4549 #endif
4550 if (__builtin_expect(dpy != NULL, 1)) {
4551 #ifdef USE_XCB
4552 xcb_connection_t *c = XGetXCBConnection(dpy);
4553 (void) __glXFlushRenderBuffer(gc, gc->pc);
4554 xcb_glx_get_tex_parameterfv_reply_t *reply =
4555 xcb_glx_get_tex_parameterfv_reply(c,
4556 xcb_glx_get_tex_parameterfv(c,
4557 gc->
4558 currentContextTag,
4559 target,
4560 pname),
4561 NULL);
4562 if (xcb_glx_get_tex_parameterfv_data_length(reply) == 0)
4563 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4564 else
4565 (void) memcpy(params, xcb_glx_get_tex_parameterfv_data(reply),
4566 xcb_glx_get_tex_parameterfv_data_length(reply) *
4567 sizeof(GLfloat));
4568 free(reply);
4569 #else
4570 GLubyte const *pc =
4571 __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
4572 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4573 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4574 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4575 UnlockDisplay(dpy);
4576 SyncHandle();
4577 #endif /* USE_XCB */
4578 }
4579 return;
4580 }
4581
4582 #define X_GLsop_GetTexParameteriv 137
4583 void
4584 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
4585 {
4586 __GLXcontext *const gc = __glXGetCurrentContext();
4587 Display *const dpy = gc->currentDpy;
4588 #ifndef USE_XCB
4589 const GLuint cmdlen = 8;
4590 #endif
4591 if (__builtin_expect(dpy != NULL, 1)) {
4592 #ifdef USE_XCB
4593 xcb_connection_t *c = XGetXCBConnection(dpy);
4594 (void) __glXFlushRenderBuffer(gc, gc->pc);
4595 xcb_glx_get_tex_parameteriv_reply_t *reply =
4596 xcb_glx_get_tex_parameteriv_reply(c,
4597 xcb_glx_get_tex_parameteriv(c,
4598 gc->
4599 currentContextTag,
4600 target,
4601 pname),
4602 NULL);
4603 if (xcb_glx_get_tex_parameteriv_data_length(reply) == 0)
4604 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4605 else
4606 (void) memcpy(params, xcb_glx_get_tex_parameteriv_data(reply),
4607 xcb_glx_get_tex_parameteriv_data_length(reply) *
4608 sizeof(GLint));
4609 free(reply);
4610 #else
4611 GLubyte const *pc =
4612 __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
4613 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4614 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4615 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4616 UnlockDisplay(dpy);
4617 SyncHandle();
4618 #endif /* USE_XCB */
4619 }
4620 return;
4621 }
4622
4623 #define X_GLsop_GetTexLevelParameterfv 138
4624 void
4625 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname,
4626 GLfloat * params)
4627 {
4628 __GLXcontext *const gc = __glXGetCurrentContext();
4629 Display *const dpy = gc->currentDpy;
4630 #ifndef USE_XCB
4631 const GLuint cmdlen = 12;
4632 #endif
4633 if (__builtin_expect(dpy != NULL, 1)) {
4634 #ifdef USE_XCB
4635 xcb_connection_t *c = XGetXCBConnection(dpy);
4636 (void) __glXFlushRenderBuffer(gc, gc->pc);
4637 xcb_glx_get_tex_level_parameterfv_reply_t *reply =
4638 xcb_glx_get_tex_level_parameterfv_reply(c,
4639 xcb_glx_get_tex_level_parameterfv
4640 (c, gc->currentContextTag,
4641 target, level, pname),
4642 NULL);
4643 if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 0)
4644 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4645 else
4646 (void) memcpy(params,
4647 xcb_glx_get_tex_level_parameterfv_data(reply),
4648 xcb_glx_get_tex_level_parameterfv_data_length(reply)
4649 * sizeof(GLfloat));
4650 free(reply);
4651 #else
4652 GLubyte const *pc =
4653 __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv,
4654 cmdlen);
4655 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4656 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4657 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
4658 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4659 UnlockDisplay(dpy);
4660 SyncHandle();
4661 #endif /* USE_XCB */
4662 }
4663 return;
4664 }
4665
4666 #define X_GLsop_GetTexLevelParameteriv 139
4667 void
4668 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname,
4669 GLint * params)
4670 {
4671 __GLXcontext *const gc = __glXGetCurrentContext();
4672 Display *const dpy = gc->currentDpy;
4673 #ifndef USE_XCB
4674 const GLuint cmdlen = 12;
4675 #endif
4676 if (__builtin_expect(dpy != NULL, 1)) {
4677 #ifdef USE_XCB
4678 xcb_connection_t *c = XGetXCBConnection(dpy);
4679 (void) __glXFlushRenderBuffer(gc, gc->pc);
4680 xcb_glx_get_tex_level_parameteriv_reply_t *reply =
4681 xcb_glx_get_tex_level_parameteriv_reply(c,
4682 xcb_glx_get_tex_level_parameteriv
4683 (c, gc->currentContextTag,
4684 target, level, pname),
4685 NULL);
4686 if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 0)
4687 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4688 else
4689 (void) memcpy(params,
4690 xcb_glx_get_tex_level_parameteriv_data(reply),
4691 xcb_glx_get_tex_level_parameteriv_data_length(reply)
4692 * sizeof(GLint));
4693 free(reply);
4694 #else
4695 GLubyte const *pc =
4696 __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv,
4697 cmdlen);
4698 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4699 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4700 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
4701 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4702 UnlockDisplay(dpy);
4703 SyncHandle();
4704 #endif /* USE_XCB */
4705 }
4706 return;
4707 }
4708
4709 #define X_GLsop_IsList 141
4710 GLboolean
4711 __indirect_glIsList(GLuint list)
4712 {
4713 __GLXcontext *const gc = __glXGetCurrentContext();
4714 Display *const dpy = gc->currentDpy;
4715 GLboolean retval = (GLboolean) 0;
4716 #ifndef USE_XCB
4717 const GLuint cmdlen = 4;
4718 #endif
4719 if (__builtin_expect(dpy != NULL, 1)) {
4720 #ifdef USE_XCB
4721 xcb_connection_t *c = XGetXCBConnection(dpy);
4722 (void) __glXFlushRenderBuffer(gc, gc->pc);
4723 xcb_glx_is_list_reply_t *reply =
4724 xcb_glx_is_list_reply(c,
4725 xcb_glx_is_list(c, gc->currentContextTag,
4726 list), NULL);
4727 retval = reply->ret_val;
4728 free(reply);
4729 #else
4730 GLubyte const *pc =
4731 __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
4732 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
4733 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
4734 UnlockDisplay(dpy);
4735 SyncHandle();
4736 #endif /* USE_XCB */
4737 }
4738 return retval;
4739 }
4740
4741 #define X_GLrop_DepthRange 174
4742 void
4743 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
4744 {
4745 __GLXcontext *const gc = __glXGetCurrentContext();
4746 const GLuint cmdlen = 20;
4747 emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
4748 (void) memcpy((void *) (gc->pc + 4), (void *) (&zNear), 8);
4749 (void) memcpy((void *) (gc->pc + 12), (void *) (&zFar), 8);
4750 gc->pc += cmdlen;
4751 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4752 (void) __glXFlushRenderBuffer(gc, gc->pc);
4753 }
4754 }
4755
4756 #define X_GLrop_Frustum 175
4757 void
4758 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom,
4759 GLdouble top, GLdouble zNear, GLdouble zFar)
4760 {
4761 __GLXcontext *const gc = __glXGetCurrentContext();
4762 const GLuint cmdlen = 52;
4763 emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
4764 (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
4765 (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
4766 (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
4767 (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
4768 (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
4769 (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
4770 gc->pc += cmdlen;
4771 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4772 (void) __glXFlushRenderBuffer(gc, gc->pc);
4773 }
4774 }
4775
4776 #define X_GLrop_LoadIdentity 176
4777 void
4778 __indirect_glLoadIdentity(void)
4779 {
4780 __GLXcontext *const gc = __glXGetCurrentContext();
4781 const GLuint cmdlen = 4;
4782 emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
4783 gc->pc += cmdlen;
4784 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4785 (void) __glXFlushRenderBuffer(gc, gc->pc);
4786 }
4787 }
4788
4789 #define X_GLrop_LoadMatrixf 177
4790 void
4791 __indirect_glLoadMatrixf(const GLfloat * m)
4792 {
4793 __GLXcontext *const gc = __glXGetCurrentContext();
4794 const GLuint cmdlen = 68;
4795 emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
4796 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
4797 gc->pc += cmdlen;
4798 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4799 (void) __glXFlushRenderBuffer(gc, gc->pc);
4800 }
4801 }
4802
4803 #define X_GLrop_LoadMatrixd 178
4804 void
4805 __indirect_glLoadMatrixd(const GLdouble * m)
4806 {
4807 __GLXcontext *const gc = __glXGetCurrentContext();
4808 const GLuint cmdlen = 132;
4809 emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
4810 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
4811 gc->pc += cmdlen;
4812 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4813 (void) __glXFlushRenderBuffer(gc, gc->pc);
4814 }
4815 }
4816
4817 #define X_GLrop_MatrixMode 179
4818 void
4819 __indirect_glMatrixMode(GLenum mode)
4820 {
4821 __GLXcontext *const gc = __glXGetCurrentContext();
4822 const GLuint cmdlen = 8;
4823 emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
4824 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
4825 gc->pc += cmdlen;
4826 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4827 (void) __glXFlushRenderBuffer(gc, gc->pc);
4828 }
4829 }
4830
4831 #define X_GLrop_MultMatrixf 180
4832 void
4833 __indirect_glMultMatrixf(const GLfloat * m)
4834 {
4835 __GLXcontext *const gc = __glXGetCurrentContext();
4836 const GLuint cmdlen = 68;
4837 emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
4838 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
4839 gc->pc += cmdlen;
4840 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4841 (void) __glXFlushRenderBuffer(gc, gc->pc);
4842 }
4843 }
4844
4845 #define X_GLrop_MultMatrixd 181
4846 void
4847 __indirect_glMultMatrixd(const GLdouble * m)
4848 {
4849 __GLXcontext *const gc = __glXGetCurrentContext();
4850 const GLuint cmdlen = 132;
4851 emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
4852 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
4853 gc->pc += cmdlen;
4854 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4855 (void) __glXFlushRenderBuffer(gc, gc->pc);
4856 }
4857 }
4858
4859 #define X_GLrop_Ortho 182
4860 void
4861 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom,
4862 GLdouble top, GLdouble zNear, GLdouble zFar)
4863 {
4864 __GLXcontext *const gc = __glXGetCurrentContext();
4865 const GLuint cmdlen = 52;
4866 emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
4867 (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
4868 (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
4869 (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
4870 (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
4871 (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
4872 (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
4873 gc->pc += cmdlen;
4874 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4875 (void) __glXFlushRenderBuffer(gc, gc->pc);
4876 }
4877 }
4878
4879 #define X_GLrop_PopMatrix 183
4880 void
4881 __indirect_glPopMatrix(void)
4882 {
4883 __GLXcontext *const gc = __glXGetCurrentContext();
4884 const GLuint cmdlen = 4;
4885 emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
4886 gc->pc += cmdlen;
4887 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4888 (void) __glXFlushRenderBuffer(gc, gc->pc);
4889 }
4890 }
4891
4892 #define X_GLrop_PushMatrix 184
4893 void
4894 __indirect_glPushMatrix(void)
4895 {
4896 __GLXcontext *const gc = __glXGetCurrentContext();
4897 const GLuint cmdlen = 4;
4898 emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
4899 gc->pc += cmdlen;
4900 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4901 (void) __glXFlushRenderBuffer(gc, gc->pc);
4902 }
4903 }
4904
4905 #define X_GLrop_Rotated 185
4906 void
4907 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
4908 {
4909 __GLXcontext *const gc = __glXGetCurrentContext();
4910 const GLuint cmdlen = 36;
4911 emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
4912 (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 8);
4913 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
4914 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
4915 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
4916 gc->pc += cmdlen;
4917 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4918 (void) __glXFlushRenderBuffer(gc, gc->pc);
4919 }
4920 }
4921
4922 #define X_GLrop_Rotatef 186
4923 void
4924 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
4925 {
4926 __GLXcontext *const gc = __glXGetCurrentContext();
4927 const GLuint cmdlen = 20;
4928 emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
4929 (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 4);
4930 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
4931 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
4932 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
4933 gc->pc += cmdlen;
4934 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4935 (void) __glXFlushRenderBuffer(gc, gc->pc);
4936 }
4937 }
4938
4939 #define X_GLrop_Scaled 187
4940 void
4941 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
4942 {
4943 __GLXcontext *const gc = __glXGetCurrentContext();
4944 const GLuint cmdlen = 28;
4945 emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
4946 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
4947 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
4948 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
4949 gc->pc += cmdlen;
4950 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4951 (void) __glXFlushRenderBuffer(gc, gc->pc);
4952 }
4953 }
4954
4955 #define X_GLrop_Scalef 188
4956 void
4957 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
4958 {
4959 __GLXcontext *const gc = __glXGetCurrentContext();
4960 const GLuint cmdlen = 16;
4961 emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
4962 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
4963 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
4964 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
4965 gc->pc += cmdlen;
4966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4967 (void) __glXFlushRenderBuffer(gc, gc->pc);
4968 }
4969 }
4970
4971 #define X_GLrop_Translated 189
4972 void
4973 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
4974 {
4975 __GLXcontext *const gc = __glXGetCurrentContext();
4976 const GLuint cmdlen = 28;
4977 emit_header(gc->pc, X_GLrop_Translated, cmdlen);
4978 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
4979 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
4980 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
4981 gc->pc += cmdlen;
4982 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4983 (void) __glXFlushRenderBuffer(gc, gc->pc);
4984 }
4985 }
4986
4987 #define X_GLrop_Translatef 190
4988 void
4989 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
4990 {
4991 __GLXcontext *const gc = __glXGetCurrentContext();
4992 const GLuint cmdlen = 16;
4993 emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
4994 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
4995 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
4996 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
4997 gc->pc += cmdlen;
4998 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4999 (void) __glXFlushRenderBuffer(gc, gc->pc);
5000 }
5001 }
5002
5003 #define X_GLrop_Viewport 191
5004 void
5005 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
5006 {
5007 __GLXcontext *const gc = __glXGetCurrentContext();
5008 const GLuint cmdlen = 20;
5009 emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
5010 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
5011 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
5012 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
5013 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
5014 gc->pc += cmdlen;
5015 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5016 (void) __glXFlushRenderBuffer(gc, gc->pc);
5017 }
5018 }
5019
5020 #define X_GLrop_BindTexture 4117
5021 void
5022 __indirect_glBindTexture(GLenum target, GLuint texture)
5023 {
5024 __GLXcontext *const gc = __glXGetCurrentContext();
5025 const GLuint cmdlen = 12;
5026 emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
5027 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5028 (void) memcpy((void *) (gc->pc + 8), (void *) (&texture), 4);
5029 gc->pc += cmdlen;
5030 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5031 (void) __glXFlushRenderBuffer(gc, gc->pc);
5032 }
5033 }
5034
5035 #define X_GLrop_Indexubv 194
5036 void
5037 __indirect_glIndexub(GLubyte c)
5038 {
5039 __GLXcontext *const gc = __glXGetCurrentContext();
5040 const GLuint cmdlen = 8;
5041 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
5042 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 1);
5043 gc->pc += cmdlen;
5044 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5045 (void) __glXFlushRenderBuffer(gc, gc->pc);
5046 }
5047 }
5048
5049 #define X_GLrop_Indexubv 194
5050 void
5051 __indirect_glIndexubv(const GLubyte *c)
5052 {
5053 __GLXcontext *const gc = __glXGetCurrentContext();
5054 const GLuint cmdlen = 8;
5055 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
5056 (void) memcpy((void *) (gc->pc + 4), (void *) (c), 1);
5057 gc->pc += cmdlen;
5058 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5059 (void) __glXFlushRenderBuffer(gc, gc->pc);
5060 }
5061 }
5062
5063 #define X_GLrop_PolygonOffset 192
5064 void
5065 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
5066 {
5067 __GLXcontext *const gc = __glXGetCurrentContext();
5068 const GLuint cmdlen = 12;
5069 emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
5070 (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
5071 (void) memcpy((void *) (gc->pc + 8), (void *) (&units), 4);
5072 gc->pc += cmdlen;
5073 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5074 (void) __glXFlushRenderBuffer(gc, gc->pc);
5075 }
5076 }
5077
5078 #define X_GLrop_CopyTexImage1D 4119
5079 void
5080 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
5081 GLint x, GLint y, GLsizei width, GLint border)
5082 {
5083 __GLXcontext *const gc = __glXGetCurrentContext();
5084 const GLuint cmdlen = 32;
5085 emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
5086 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5087 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5088 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
5089 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5090 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5091 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5092 (void) memcpy((void *) (gc->pc + 28), (void *) (&border), 4);
5093 gc->pc += cmdlen;
5094 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5095 (void) __glXFlushRenderBuffer(gc, gc->pc);
5096 }
5097 }
5098
5099 #define X_GLrop_CopyTexImage2D 4120
5100 void
5101 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
5102 GLint x, GLint y, GLsizei width, GLsizei height,
5103 GLint border)
5104 {
5105 __GLXcontext *const gc = __glXGetCurrentContext();
5106 const GLuint cmdlen = 36;
5107 emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
5108 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5109 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5110 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
5111 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5112 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5113 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5114 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
5115 (void) memcpy((void *) (gc->pc + 32), (void *) (&border), 4);
5116 gc->pc += cmdlen;
5117 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5118 (void) __glXFlushRenderBuffer(gc, gc->pc);
5119 }
5120 }
5121
5122 #define X_GLrop_CopyTexSubImage1D 4121
5123 void
5124 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset,
5125 GLint x, GLint y, GLsizei width)
5126 {
5127 __GLXcontext *const gc = __glXGetCurrentContext();
5128 const GLuint cmdlen = 28;
5129 emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
5130 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5131 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5132 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
5133 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5134 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5135 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5136 gc->pc += cmdlen;
5137 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5138 (void) __glXFlushRenderBuffer(gc, gc->pc);
5139 }
5140 }
5141
5142 #define X_GLrop_CopyTexSubImage2D 4122
5143 void
5144 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
5145 GLint yoffset, GLint x, GLint y, GLsizei width,
5146 GLsizei height)
5147 {
5148 __GLXcontext *const gc = __glXGetCurrentContext();
5149 const GLuint cmdlen = 36;
5150 emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
5151 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5152 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5153 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
5154 (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
5155 (void) memcpy((void *) (gc->pc + 20), (void *) (&x), 4);
5156 (void) memcpy((void *) (gc->pc + 24), (void *) (&y), 4);
5157 (void) memcpy((void *) (gc->pc + 28), (void *) (&width), 4);
5158 (void) memcpy((void *) (gc->pc + 32), (void *) (&height), 4);
5159 gc->pc += cmdlen;
5160 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5161 (void) __glXFlushRenderBuffer(gc, gc->pc);
5162 }
5163 }
5164
5165 #define X_GLsop_DeleteTextures 144
5166 void
5167 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
5168 {
5169 __GLXcontext *const gc = __glXGetCurrentContext();
5170 Display *const dpy = gc->currentDpy;
5171 #ifndef USE_XCB
5172 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5173 #endif
5174 if (n < 0) {
5175 __glXSetError(gc, GL_INVALID_VALUE);
5176 return;
5177 }
5178 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5179 #ifdef USE_XCB
5180 xcb_connection_t *c = XGetXCBConnection(dpy);
5181 (void) __glXFlushRenderBuffer(gc, gc->pc);
5182 xcb_glx_delete_textures(c, gc->currentContextTag, n, textures);
5183 #else
5184 GLubyte const *pc =
5185 __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen);
5186 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5187 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5188 UnlockDisplay(dpy);
5189 SyncHandle();
5190 #endif /* USE_XCB */
5191 }
5192 return;
5193 }
5194
5195 #define X_GLvop_DeleteTexturesEXT 12
5196 void
5197 glDeleteTexturesEXT(GLsizei n, const GLuint * textures)
5198 {
5199 __GLXcontext *const gc = __glXGetCurrentContext();
5200
5201 if (gc->driContext) {
5202 CALL_DeleteTextures(GET_DISPATCH(), (n, textures));
5203 } else {
5204 __GLXcontext *const gc = __glXGetCurrentContext();
5205 Display *const dpy = gc->currentDpy;
5206 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5207 if (n < 0) {
5208 __glXSetError(gc, GL_INVALID_VALUE);
5209 return;
5210 }
5211 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5212 GLubyte const *pc =
5213 __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
5214 X_GLvop_DeleteTexturesEXT, cmdlen);
5215 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5216 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5217 UnlockDisplay(dpy);
5218 SyncHandle();
5219 }
5220 return;
5221 }
5222 }
5223
5224 #define X_GLsop_GenTextures 145
5225 void
5226 __indirect_glGenTextures(GLsizei n, GLuint * textures)
5227 {
5228 __GLXcontext *const gc = __glXGetCurrentContext();
5229 Display *const dpy = gc->currentDpy;
5230 #ifndef USE_XCB
5231 const GLuint cmdlen = 4;
5232 #endif
5233 if (n < 0) {
5234 __glXSetError(gc, GL_INVALID_VALUE);
5235 return;
5236 }
5237 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5238 #ifdef USE_XCB
5239 xcb_connection_t *c = XGetXCBConnection(dpy);
5240 (void) __glXFlushRenderBuffer(gc, gc->pc);
5241 xcb_glx_gen_textures_reply_t *reply =
5242 xcb_glx_gen_textures_reply(c,
5243 xcb_glx_gen_textures(c,
5244 gc->
5245 currentContextTag,
5246 n), NULL);
5247 (void) memcpy(textures, xcb_glx_gen_textures_data(reply),
5248 xcb_glx_gen_textures_data_length(reply) *
5249 sizeof(GLuint));
5250 free(reply);
5251 #else
5252 GLubyte const *pc =
5253 __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
5254 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5255 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5256 UnlockDisplay(dpy);
5257 SyncHandle();
5258 #endif /* USE_XCB */
5259 }
5260 return;
5261 }
5262
5263 #define X_GLvop_GenTexturesEXT 13
5264 void
5265 glGenTexturesEXT(GLsizei n, GLuint * textures)
5266 {
5267 __GLXcontext *const gc = __glXGetCurrentContext();
5268
5269 if (gc->driContext) {
5270 CALL_GenTextures(GET_DISPATCH(), (n, textures));
5271 } else {
5272 __GLXcontext *const gc = __glXGetCurrentContext();
5273 Display *const dpy = gc->currentDpy;
5274 const GLuint cmdlen = 4;
5275 if (n < 0) {
5276 __glXSetError(gc, GL_INVALID_VALUE);
5277 return;
5278 }
5279 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5280 GLubyte const *pc =
5281 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5282 X_GLvop_GenTexturesEXT, cmdlen);
5283 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5284 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5285 UnlockDisplay(dpy);
5286 SyncHandle();
5287 }
5288 return;
5289 }
5290 }
5291
5292 #define X_GLsop_IsTexture 146
5293 GLboolean
5294 __indirect_glIsTexture(GLuint texture)
5295 {
5296 __GLXcontext *const gc = __glXGetCurrentContext();
5297 Display *const dpy = gc->currentDpy;
5298 GLboolean retval = (GLboolean) 0;
5299 #ifndef USE_XCB
5300 const GLuint cmdlen = 4;
5301 #endif
5302 if (__builtin_expect(dpy != NULL, 1)) {
5303 #ifdef USE_XCB
5304 xcb_connection_t *c = XGetXCBConnection(dpy);
5305 (void) __glXFlushRenderBuffer(gc, gc->pc);
5306 xcb_glx_is_texture_reply_t *reply =
5307 xcb_glx_is_texture_reply(c,
5308 xcb_glx_is_texture(c,
5309 gc->currentContextTag,
5310 texture), NULL);
5311 retval = reply->ret_val;
5312 free(reply);
5313 #else
5314 GLubyte const *pc =
5315 __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
5316 (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
5317 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5318 UnlockDisplay(dpy);
5319 SyncHandle();
5320 #endif /* USE_XCB */
5321 }
5322 return retval;
5323 }
5324
5325 #define X_GLvop_IsTextureEXT 14
5326 GLboolean
5327 glIsTextureEXT(GLuint texture)
5328 {
5329 __GLXcontext *const gc = __glXGetCurrentContext();
5330
5331 if (gc->driContext) {
5332 return CALL_IsTexture(GET_DISPATCH(), (texture));
5333 } else {
5334 __GLXcontext *const gc = __glXGetCurrentContext();
5335 Display *const dpy = gc->currentDpy;
5336 GLboolean retval = (GLboolean) 0;
5337 const GLuint cmdlen = 4;
5338 if (__builtin_expect(dpy != NULL, 1)) {
5339 GLubyte const *pc =
5340 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5341 X_GLvop_IsTextureEXT, cmdlen);
5342 (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
5343 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5344 UnlockDisplay(dpy);
5345 SyncHandle();
5346 }
5347 return retval;
5348 }
5349 }
5350
5351 #define X_GLrop_PrioritizeTextures 4118
5352 void
5353 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures,
5354 const GLclampf * priorities)
5355 {
5356 __GLXcontext *const gc = __glXGetCurrentContext();
5357 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
5358 if (n < 0) {
5359 __glXSetError(gc, GL_INVALID_VALUE);
5360 return;
5361 }
5362 if (__builtin_expect(n >= 0, 1)) {
5363 emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
5364 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
5365 (void) memcpy((void *) (gc->pc + 8), (void *) (textures), (n * 4));
5366 (void) memcpy((void *) (gc->pc + 8 + (n * 4)), (void *) (priorities),
5367 (n * 4));
5368 gc->pc += cmdlen;
5369 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5370 (void) __glXFlushRenderBuffer(gc, gc->pc);
5371 }
5372 }
5373 }
5374
5375 static void
5376 __glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target,
5377 GLint level, GLint xoffset, GLint yoffset,
5378 GLsizei width, GLsizei height, GLenum format,
5379 GLenum type, const GLvoid * pixels)
5380 {
5381 __GLXcontext *const gc = __glXGetCurrentContext();
5382 const GLuint compsize =
5383 (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
5384 target) : 0;
5385 const GLuint cmdlen = 60 + __GLX_PAD(compsize);
5386 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5387 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5388 if ((gc->pc + cmdlen) > gc->bufEnd) {
5389 (void) __glXFlushRenderBuffer(gc, gc->pc);
5390 }
5391 emit_header(gc->pc, opcode, cmdlen);
5392 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5393 (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
5394 (void) memcpy((void *) (gc->pc + 32), (void *) (&xoffset), 4);
5395 (void) memcpy((void *) (gc->pc + 36), (void *) (&yoffset), 4);
5396 (void) memcpy((void *) (gc->pc + 40), (void *) (&width), 4);
5397 (void) memcpy((void *) (gc->pc + 44), (void *) (&height), 4);
5398 (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
5399 (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
5400 (void) memset((void *) (gc->pc + 56), 0, 4);
5401 if (compsize > 0) {
5402 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
5403 pixels, gc->pc + 60, gc->pc + 4);
5404 } else {
5405 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
5406 default_pixel_store_2D_size);
5407 }
5408 gc->pc += cmdlen;
5409 if (gc->pc > gc->limit) {
5410 (void) __glXFlushRenderBuffer(gc, gc->pc);
5411 }
5412 } else {
5413 const GLint op = opcode;
5414 const GLuint cmdlenLarge = cmdlen + 4;
5415 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5416 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5417 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5418 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5419 (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
5420 (void) memcpy((void *) (pc + 36), (void *) (&xoffset), 4);
5421 (void) memcpy((void *) (pc + 40), (void *) (&yoffset), 4);
5422 (void) memcpy((void *) (pc + 44), (void *) (&width), 4);
5423 (void) memcpy((void *) (pc + 48), (void *) (&height), 4);
5424 (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
5425 (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
5426 (void) memset((void *) (pc + 60), 0, 4);
5427 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
5428 type, pixels, pc + 64, pc + 8);
5429 }
5430 }
5431 }
5432
5433 #define X_GLrop_TexSubImage1D 4099
5434 void
5435 __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset,
5436 GLsizei width, GLenum format, GLenum type,
5437 const GLvoid * pixels)
5438 {
5439 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset,
5440 1, width, 1, format, type, pixels);
5441 }
5442
5443 #define X_GLrop_TexSubImage2D 4100
5444 void
5445 __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
5446 GLint yoffset, GLsizei width, GLsizei height,
5447 GLenum format, GLenum type, const GLvoid * pixels)
5448 {
5449 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset,
5450 yoffset, width, height, format, type, pixels);
5451 }
5452
5453 #define X_GLrop_BlendColor 4096
5454 void
5455 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
5456 GLclampf alpha)
5457 {
5458 __GLXcontext *const gc = __glXGetCurrentContext();
5459 const GLuint cmdlen = 20;
5460 emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
5461 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
5462 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
5463 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
5464 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
5465 gc->pc += cmdlen;
5466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5467 (void) __glXFlushRenderBuffer(gc, gc->pc);
5468 }
5469 }
5470
5471 #define X_GLrop_BlendEquation 4097
5472 void
5473 __indirect_glBlendEquation(GLenum mode)
5474 {
5475 __GLXcontext *const gc = __glXGetCurrentContext();
5476 const GLuint cmdlen = 8;
5477 emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
5478 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
5479 gc->pc += cmdlen;
5480 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5481 (void) __glXFlushRenderBuffer(gc, gc->pc);
5482 }
5483 }
5484
5485 #define X_GLrop_ColorTable 2053
5486 void
5487 __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width,
5488 GLenum format, GLenum type, const GLvoid * table)
5489 {
5490 __GLXcontext *const gc = __glXGetCurrentContext();
5491 const GLuint compsize =
5492 (table != NULL) ? __glImageSize(width, 1, 1, format, type,
5493 target) : 0;
5494 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
5495 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5496 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5497 if ((gc->pc + cmdlen) > gc->bufEnd) {
5498 (void) __glXFlushRenderBuffer(gc, gc->pc);
5499 }
5500 emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
5501 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5502 (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
5503 4);
5504 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
5505 (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
5506 (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
5507 if (compsize > 0) {
5508 (*gc->fillImage) (gc, 1, width, 1, 1, format, type, table,
5509 gc->pc + 44, gc->pc + 4);
5510 } else {
5511 (void) memcpy(gc->pc + 4, default_pixel_store_1D,
5512 default_pixel_store_1D_size);
5513 }
5514 gc->pc += cmdlen;
5515 if (gc->pc > gc->limit) {
5516 (void) __glXFlushRenderBuffer(gc, gc->pc);
5517 }
5518 } else {
5519 const GLint op = X_GLrop_ColorTable;
5520 const GLuint cmdlenLarge = cmdlen + 4;
5521 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5522 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5523 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5524 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5525 (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
5526 (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
5527 (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
5528 (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
5529 __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type,
5530 table, pc + 48, pc + 8);
5531 }
5532 }
5533 }
5534
5535 #define X_GLrop_ColorTableParameterfv 2054
5536 void
5537 __indirect_glColorTableParameterfv(GLenum target, GLenum pname,
5538 const GLfloat * params)
5539 {
5540 __GLXcontext *const gc = __glXGetCurrentContext();
5541 const GLuint compsize = __glColorTableParameterfv_size(pname);
5542 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5543 emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
5544 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5545 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5546 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5547 gc->pc += cmdlen;
5548 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5549 (void) __glXFlushRenderBuffer(gc, gc->pc);
5550 }
5551 }
5552
5553 #define X_GLrop_ColorTableParameteriv 2055
5554 void
5555 __indirect_glColorTableParameteriv(GLenum target, GLenum pname,
5556 const GLint * params)
5557 {
5558 __GLXcontext *const gc = __glXGetCurrentContext();
5559 const GLuint compsize = __glColorTableParameteriv_size(pname);
5560 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5561 emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
5562 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5563 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5564 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5565 gc->pc += cmdlen;
5566 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5567 (void) __glXFlushRenderBuffer(gc, gc->pc);
5568 }
5569 }
5570
5571 #define X_GLrop_CopyColorTable 2056
5572 void
5573 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x,
5574 GLint y, GLsizei width)
5575 {
5576 __GLXcontext *const gc = __glXGetCurrentContext();
5577 const GLuint cmdlen = 24;
5578 emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
5579 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5580 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
5581 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
5582 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
5583 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
5584 gc->pc += cmdlen;
5585 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5586 (void) __glXFlushRenderBuffer(gc, gc->pc);
5587 }
5588 }
5589
5590 #define X_GLsop_GetColorTable 147
5591 void
5592 __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type,
5593 GLvoid * table)
5594 {
5595 __GLXcontext *const gc = __glXGetCurrentContext();
5596 const __GLXattribute *const state = gc->client_state_private;
5597 Display *const dpy = gc->currentDpy;
5598 #ifndef USE_XCB
5599 const GLuint cmdlen = 16;
5600 #endif
5601 if (__builtin_expect(dpy != NULL, 1)) {
5602 #ifdef USE_XCB
5603 xcb_connection_t *c = XGetXCBConnection(dpy);
5604 (void) __glXFlushRenderBuffer(gc, gc->pc);
5605 xcb_glx_get_color_table_reply_t *reply =
5606 xcb_glx_get_color_table_reply(c,
5607 xcb_glx_get_color_table(c,
5608 gc->
5609 currentContextTag,
5610 target,
5611 format,
5612 type,
5613 state->
5614 storePack.
5615 swapEndian),
5616 NULL);
5617 (void) memcpy(table, xcb_glx_get_color_table_data(reply),
5618 xcb_glx_get_color_table_data_length(reply) *
5619 sizeof(GLvoid));
5620 free(reply);
5621 #else
5622 GLubyte const *pc =
5623 __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
5624 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5625 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
5626 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
5627 *(int32_t *) (pc + 12) = 0;
5628 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
5629 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
5630 GL_TRUE);
5631 UnlockDisplay(dpy);
5632 SyncHandle();
5633 #endif /* USE_XCB */
5634 }
5635 return;
5636 }
5637
5638 #define X_GLvop_GetColorTableSGI 4098
5639 void
5640 glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * table)
5641 {
5642 __GLXcontext *const gc = __glXGetCurrentContext();
5643
5644 if (gc->driContext) {
5645 CALL_GetColorTable(GET_DISPATCH(), (target, format, type, table));
5646 } else {
5647 __GLXcontext *const gc = __glXGetCurrentContext();
5648 const __GLXattribute *const state = gc->client_state_private;
5649 Display *const dpy = gc->currentDpy;
5650 const GLuint cmdlen = 16;
5651 if (__builtin_expect(dpy != NULL, 1)) {
5652 GLubyte const *pc =
5653 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5654 X_GLvop_GetColorTableSGI, cmdlen);
5655 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5656 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
5657 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
5658 *(int32_t *) (pc + 12) = 0;
5659 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
5660 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
5661 GL_TRUE);
5662 UnlockDisplay(dpy);
5663 SyncHandle();
5664 }
5665 return;
5666 }
5667 }
5668
5669 #define X_GLsop_GetColorTableParameterfv 148
5670 void
5671 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname,
5672 GLfloat * params)
5673 {
5674 __GLXcontext *const gc = __glXGetCurrentContext();
5675 Display *const dpy = gc->currentDpy;
5676 #ifndef USE_XCB
5677 const GLuint cmdlen = 8;
5678 #endif
5679 if (__builtin_expect(dpy != NULL, 1)) {
5680 #ifdef USE_XCB
5681 xcb_connection_t *c = XGetXCBConnection(dpy);
5682 (void) __glXFlushRenderBuffer(gc, gc->pc);
5683 xcb_glx_get_color_table_parameterfv_reply_t *reply =
5684 xcb_glx_get_color_table_parameterfv_reply(c,
5685 xcb_glx_get_color_table_parameterfv
5686 (c,
5687 gc->currentContextTag,
5688 target, pname), NULL);
5689 if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 0)
5690 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
5691 else
5692 (void) memcpy(params,
5693 xcb_glx_get_color_table_parameterfv_data(reply),
5694 xcb_glx_get_color_table_parameterfv_data_length
5695 (reply) * sizeof(GLfloat));
5696 free(reply);
5697 #else
5698 GLubyte const *pc =
5699 __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv,
5700 cmdlen);
5701 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5702 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5703 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5704 UnlockDisplay(dpy);
5705 SyncHandle();
5706 #endif /* USE_XCB */
5707 }
5708 return;
5709 }
5710
5711 #define X_GLvop_GetColorTableParameterfvSGI 4099
5712 void
5713 glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
5714 {
5715 __GLXcontext *const gc = __glXGetCurrentContext();
5716
5717 if (gc->driContext) {
5718 CALL_GetColorTableParameterfv(GET_DISPATCH(),
5719 (target, pname, params));
5720 } else {
5721 __GLXcontext *const gc = __glXGetCurrentContext();
5722 Display *const dpy = gc->currentDpy;
5723 const GLuint cmdlen = 8;
5724 if (__builtin_expect(dpy != NULL, 1)) {
5725 GLubyte const *pc =
5726 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5727 X_GLvop_GetColorTableParameterfvSGI,
5728 cmdlen);
5729 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5730 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5731 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5732 UnlockDisplay(dpy);
5733 SyncHandle();
5734 }
5735 return;
5736 }
5737 }
5738
5739 #define X_GLsop_GetColorTableParameteriv 149
5740 void
5741 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname,
5742 GLint * params)
5743 {
5744 __GLXcontext *const gc = __glXGetCurrentContext();
5745 Display *const dpy = gc->currentDpy;
5746 #ifndef USE_XCB
5747 const GLuint cmdlen = 8;
5748 #endif
5749 if (__builtin_expect(dpy != NULL, 1)) {
5750 #ifdef USE_XCB
5751 xcb_connection_t *c = XGetXCBConnection(dpy);
5752 (void) __glXFlushRenderBuffer(gc, gc->pc);
5753 xcb_glx_get_color_table_parameteriv_reply_t *reply =
5754 xcb_glx_get_color_table_parameteriv_reply(c,
5755 xcb_glx_get_color_table_parameteriv
5756 (c,
5757 gc->currentContextTag,
5758 target, pname), NULL);
5759 if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 0)
5760 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
5761 else
5762 (void) memcpy(params,
5763 xcb_glx_get_color_table_parameteriv_data(reply),
5764 xcb_glx_get_color_table_parameteriv_data_length
5765 (reply) * sizeof(GLint));
5766 free(reply);
5767 #else
5768 GLubyte const *pc =
5769 __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv,
5770 cmdlen);
5771 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5772 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5773 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5774 UnlockDisplay(dpy);
5775 SyncHandle();
5776 #endif /* USE_XCB */
5777 }
5778 return;
5779 }
5780
5781 #define X_GLvop_GetColorTableParameterivSGI 4100
5782 void
5783 glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)
5784 {
5785 __GLXcontext *const gc = __glXGetCurrentContext();
5786
5787 if (gc->driContext) {
5788 CALL_GetColorTableParameteriv(GET_DISPATCH(),
5789 (target, pname, params));
5790 } else {
5791 __GLXcontext *const gc = __glXGetCurrentContext();
5792 Display *const dpy = gc->currentDpy;
5793 const GLuint cmdlen = 8;
5794 if (__builtin_expect(dpy != NULL, 1)) {
5795 GLubyte const *pc =
5796 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5797 X_GLvop_GetColorTableParameterivSGI,
5798 cmdlen);
5799 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5800 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5801 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5802 UnlockDisplay(dpy);
5803 SyncHandle();
5804 }
5805 return;
5806 }
5807 }
5808
5809 #define X_GLrop_ColorSubTable 195
5810 void
5811 __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count,
5812 GLenum format, GLenum type, const GLvoid * data)
5813 {
5814 __GLXcontext *const gc = __glXGetCurrentContext();
5815 const GLuint compsize =
5816 (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
5817 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
5818 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5819 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5820 if ((gc->pc + cmdlen) > gc->bufEnd) {
5821 (void) __glXFlushRenderBuffer(gc, gc->pc);
5822 }
5823 emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
5824 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5825 (void) memcpy((void *) (gc->pc + 28), (void *) (&start), 4);
5826 (void) memcpy((void *) (gc->pc + 32), (void *) (&count), 4);
5827 (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
5828 (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
5829 if (compsize > 0) {
5830 (*gc->fillImage) (gc, 1, count, 1, 1, format, type, data,
5831 gc->pc + 44, gc->pc + 4);
5832 } else {
5833 (void) memcpy(gc->pc + 4, default_pixel_store_1D,
5834 default_pixel_store_1D_size);
5835 }
5836 gc->pc += cmdlen;
5837 if (gc->pc > gc->limit) {
5838 (void) __glXFlushRenderBuffer(gc, gc->pc);
5839 }
5840 } else {
5841 const GLint op = X_GLrop_ColorSubTable;
5842 const GLuint cmdlenLarge = cmdlen + 4;
5843 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5844 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5845 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5846 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5847 (void) memcpy((void *) (pc + 32), (void *) (&start), 4);
5848 (void) memcpy((void *) (pc + 36), (void *) (&count), 4);
5849 (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
5850 (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
5851 __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type,
5852 data, pc + 48, pc + 8);
5853 }
5854 }
5855 }
5856
5857 #define X_GLrop_CopyColorSubTable 196
5858 void
5859 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y,
5860 GLsizei width)
5861 {
5862 __GLXcontext *const gc = __glXGetCurrentContext();
5863 const GLuint cmdlen = 24;
5864 emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
5865 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5866 (void) memcpy((void *) (gc->pc + 8), (void *) (&start), 4);
5867 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
5868 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
5869 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
5870 gc->pc += cmdlen;
5871 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5872 (void) __glXFlushRenderBuffer(gc, gc->pc);
5873 }
5874 }
5875
5876 static void
5877 __glx_ConvolutionFilter_1D2D(unsigned opcode, unsigned dim, GLenum target,
5878 GLenum internalformat, GLsizei width,
5879 GLsizei height, GLenum format, GLenum type,
5880 const GLvoid * image)
5881 {
5882 __GLXcontext *const gc = __glXGetCurrentContext();
5883 const GLuint compsize =
5884 (image != NULL) ? __glImageSize(width, height, 1, format, type,
5885 target) : 0;
5886 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
5887 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5888 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5889 if ((gc->pc + cmdlen) > gc->bufEnd) {
5890 (void) __glXFlushRenderBuffer(gc, gc->pc);
5891 }
5892 emit_header(gc->pc, opcode, cmdlen);
5893 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5894 (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
5895 4);
5896 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
5897 (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
5898 (void) memcpy((void *) (gc->pc + 40), (void *) (&format), 4);
5899 (void) memcpy((void *) (gc->pc + 44), (void *) (&type), 4);
5900 if (compsize > 0) {
5901 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
5902 image, gc->pc + 48, gc->pc + 4);
5903 } else {
5904 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
5905 default_pixel_store_2D_size);
5906 }
5907 gc->pc += cmdlen;
5908 if (gc->pc > gc->limit) {
5909 (void) __glXFlushRenderBuffer(gc, gc->pc);
5910 }
5911 } else {
5912 const GLint op = opcode;
5913 const GLuint cmdlenLarge = cmdlen + 4;
5914 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5915 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5916 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5917 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5918 (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
5919 (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
5920 (void) memcpy((void *) (pc + 40), (void *) (&height), 4);
5921 (void) memcpy((void *) (pc + 44), (void *) (&format), 4);
5922 (void) memcpy((void *) (pc + 48), (void *) (&type), 4);
5923 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
5924 type, image, pc + 52, pc + 8);
5925 }
5926 }
5927 }
5928
5929 #define X_GLrop_ConvolutionFilter1D 4101
5930 void
5931 __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat,
5932 GLsizei width, GLenum format, GLenum type,
5933 const GLvoid * image)
5934 {
5935 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target,
5936 internalformat, width, 1, format, type,
5937 image);
5938 }
5939
5940 #define X_GLrop_ConvolutionFilter2D 4102
5941 void
5942 __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat,
5943 GLsizei width, GLsizei height, GLenum format,
5944 GLenum type, const GLvoid * image)
5945 {
5946 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target,
5947 internalformat, width, height, format, type,
5948 image);
5949 }
5950
5951 #define X_GLrop_ConvolutionParameterf 4103
5952 void
5953 __indirect_glConvolutionParameterf(GLenum target, GLenum pname,
5954 GLfloat params)
5955 {
5956 __GLXcontext *const gc = __glXGetCurrentContext();
5957 const GLuint cmdlen = 16;
5958 emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
5959 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5960 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5961 (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
5962 gc->pc += cmdlen;
5963 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5964 (void) __glXFlushRenderBuffer(gc, gc->pc);
5965 }
5966 }
5967
5968 #define X_GLrop_ConvolutionParameterfv 4104
5969 void
5970 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname,
5971 const GLfloat * params)
5972 {
5973 __GLXcontext *const gc = __glXGetCurrentContext();
5974 const GLuint compsize = __glConvolutionParameterfv_size(pname);
5975 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5976 emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
5977 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5978 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5979 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5980 gc->pc += cmdlen;
5981 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5982 (void) __glXFlushRenderBuffer(gc, gc->pc);
5983 }
5984 }
5985
5986 #define X_GLrop_ConvolutionParameteri 4105
5987 void
5988 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
5989 {
5990 __GLXcontext *const gc = __glXGetCurrentContext();
5991 const GLuint cmdlen = 16;
5992 emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
5993 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5994 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5995 (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
5996 gc->pc += cmdlen;
5997 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5998 (void) __glXFlushRenderBuffer(gc, gc->pc);
5999 }
6000 }
6001
6002 #define X_GLrop_ConvolutionParameteriv 4106
6003 void
6004 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname,
6005 const GLint * params)
6006 {
6007 __GLXcontext *const gc = __glXGetCurrentContext();
6008 const GLuint compsize = __glConvolutionParameteriv_size(pname);
6009 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
6010 emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
6011 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6012 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
6013 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
6014 gc->pc += cmdlen;
6015 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6016 (void) __glXFlushRenderBuffer(gc, gc->pc);
6017 }
6018 }
6019
6020 #define X_GLrop_CopyConvolutionFilter1D 4107
6021 void
6022 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat,
6023 GLint x, GLint y, GLsizei width)
6024 {
6025 __GLXcontext *const gc = __glXGetCurrentContext();
6026 const GLuint cmdlen = 24;
6027 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
6028 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6029 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6030 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
6031 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
6032 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
6033 gc->pc += cmdlen;
6034 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6035 (void) __glXFlushRenderBuffer(gc, gc->pc);
6036 }
6037 }
6038
6039 #define X_GLrop_CopyConvolutionFilter2D 4108
6040 void
6041 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat,
6042 GLint x, GLint y, GLsizei width,
6043 GLsizei height)
6044 {
6045 __GLXcontext *const gc = __glXGetCurrentContext();
6046 const GLuint cmdlen = 28;
6047 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
6048 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6049 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6050 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
6051 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
6052 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
6053 (void) memcpy((void *) (gc->pc + 24), (void *) (&height), 4);
6054 gc->pc += cmdlen;
6055 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6056 (void) __glXFlushRenderBuffer(gc, gc->pc);
6057 }
6058 }
6059
6060 #define X_GLsop_GetConvolutionFilter 150
6061 void
6062 __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
6063 GLvoid * image)
6064 {
6065 __GLXcontext *const gc = __glXGetCurrentContext();
6066 const __GLXattribute *const state = gc->client_state_private;
6067 Display *const dpy = gc->currentDpy;
6068 #ifndef USE_XCB
6069 const GLuint cmdlen = 16;
6070 #endif
6071 if (__builtin_expect(dpy != NULL, 1)) {
6072 #ifdef USE_XCB
6073 xcb_connection_t *c = XGetXCBConnection(dpy);
6074 (void) __glXFlushRenderBuffer(gc, gc->pc);
6075 xcb_glx_get_convolution_filter_reply_t *reply =
6076 xcb_glx_get_convolution_filter_reply(c,
6077 xcb_glx_get_convolution_filter
6078 (c, gc->currentContextTag,
6079 target, format, type,
6080 state->storePack.
6081 swapEndian), NULL);
6082 (void) memcpy(image, xcb_glx_get_convolution_filter_data(reply),
6083 xcb_glx_get_convolution_filter_data_length(reply) *
6084 sizeof(GLvoid));
6085 free(reply);
6086 #else
6087 GLubyte const *pc =
6088 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
6089 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6090 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6091 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6092 *(int32_t *) (pc + 12) = 0;
6093 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6094 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
6095 GL_TRUE);
6096 UnlockDisplay(dpy);
6097 SyncHandle();
6098 #endif /* USE_XCB */
6099 }
6100 return;
6101 }
6102
6103 #define X_GLvop_GetConvolutionFilterEXT 1
6104 void
6105 gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type,
6106 GLvoid * image)
6107 {
6108 __GLXcontext *const gc = __glXGetCurrentContext();
6109
6110 if (gc->driContext) {
6111 CALL_GetConvolutionFilter(GET_DISPATCH(),
6112 (target, format, type, image));
6113 } else {
6114 __GLXcontext *const gc = __glXGetCurrentContext();
6115 const __GLXattribute *const state = gc->client_state_private;
6116 Display *const dpy = gc->currentDpy;
6117 const GLuint cmdlen = 16;
6118 if (__builtin_expect(dpy != NULL, 1)) {
6119 GLubyte const *pc =
6120 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6121 X_GLvop_GetConvolutionFilterEXT,
6122 cmdlen);
6123 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6124 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6125 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6126 *(int32_t *) (pc + 12) = 0;
6127 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6128 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
6129 GL_TRUE);
6130 UnlockDisplay(dpy);
6131 SyncHandle();
6132 }
6133 return;
6134 }
6135 }
6136
6137 #define X_GLsop_GetConvolutionParameterfv 151
6138 void
6139 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname,
6140 GLfloat * params)
6141 {
6142 __GLXcontext *const gc = __glXGetCurrentContext();
6143 Display *const dpy = gc->currentDpy;
6144 #ifndef USE_XCB
6145 const GLuint cmdlen = 8;
6146 #endif
6147 if (__builtin_expect(dpy != NULL, 1)) {
6148 #ifdef USE_XCB
6149 xcb_connection_t *c = XGetXCBConnection(dpy);
6150 (void) __glXFlushRenderBuffer(gc, gc->pc);
6151 xcb_glx_get_convolution_parameterfv_reply_t *reply =
6152 xcb_glx_get_convolution_parameterfv_reply(c,
6153 xcb_glx_get_convolution_parameterfv
6154 (c,
6155 gc->currentContextTag,
6156 target, pname), NULL);
6157 if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 0)
6158 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6159 else
6160 (void) memcpy(params,
6161 xcb_glx_get_convolution_parameterfv_data(reply),
6162 xcb_glx_get_convolution_parameterfv_data_length
6163 (reply) * sizeof(GLfloat));
6164 free(reply);
6165 #else
6166 GLubyte const *pc =
6167 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv,
6168 cmdlen);
6169 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6170 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6171 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6172 UnlockDisplay(dpy);
6173 SyncHandle();
6174 #endif /* USE_XCB */
6175 }
6176 return;
6177 }
6178
6179 #define X_GLvop_GetConvolutionParameterfvEXT 2
6180 void
6181 gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params)
6182 {
6183 __GLXcontext *const gc = __glXGetCurrentContext();
6184
6185 if (gc->driContext) {
6186 CALL_GetConvolutionParameterfv(GET_DISPATCH(),
6187 (target, pname, params));
6188 } else {
6189 __GLXcontext *const gc = __glXGetCurrentContext();
6190 Display *const dpy = gc->currentDpy;
6191 const GLuint cmdlen = 8;
6192 if (__builtin_expect(dpy != NULL, 1)) {
6193 GLubyte const *pc =
6194 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6195 X_GLvop_GetConvolutionParameterfvEXT,
6196 cmdlen);
6197 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6198 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6199 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6200 UnlockDisplay(dpy);
6201 SyncHandle();
6202 }
6203 return;
6204 }
6205 }
6206
6207 #define X_GLsop_GetConvolutionParameteriv 152
6208 void
6209 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname,
6210 GLint * params)
6211 {
6212 __GLXcontext *const gc = __glXGetCurrentContext();
6213 Display *const dpy = gc->currentDpy;
6214 #ifndef USE_XCB
6215 const GLuint cmdlen = 8;
6216 #endif
6217 if (__builtin_expect(dpy != NULL, 1)) {
6218 #ifdef USE_XCB
6219 xcb_connection_t *c = XGetXCBConnection(dpy);
6220 (void) __glXFlushRenderBuffer(gc, gc->pc);
6221 xcb_glx_get_convolution_parameteriv_reply_t *reply =
6222 xcb_glx_get_convolution_parameteriv_reply(c,
6223 xcb_glx_get_convolution_parameteriv
6224 (c,
6225 gc->currentContextTag,
6226 target, pname), NULL);
6227 if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 0)
6228 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6229 else
6230 (void) memcpy(params,
6231 xcb_glx_get_convolution_parameteriv_data(reply),
6232 xcb_glx_get_convolution_parameteriv_data_length
6233 (reply) * sizeof(GLint));
6234 free(reply);
6235 #else
6236 GLubyte const *pc =
6237 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv,
6238 cmdlen);
6239 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6240 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6241 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6242 UnlockDisplay(dpy);
6243 SyncHandle();
6244 #endif /* USE_XCB */
6245 }
6246 return;
6247 }
6248
6249 #define X_GLvop_GetConvolutionParameterivEXT 3
6250 void
6251 gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params)
6252 {
6253 __GLXcontext *const gc = __glXGetCurrentContext();
6254
6255 if (gc->driContext) {
6256 CALL_GetConvolutionParameteriv(GET_DISPATCH(),
6257 (target, pname, params));
6258 } else {
6259 __GLXcontext *const gc = __glXGetCurrentContext();
6260 Display *const dpy = gc->currentDpy;
6261 const GLuint cmdlen = 8;
6262 if (__builtin_expect(dpy != NULL, 1)) {
6263 GLubyte const *pc =
6264 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6265 X_GLvop_GetConvolutionParameterivEXT,
6266 cmdlen);
6267 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6268 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6269 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6270 UnlockDisplay(dpy);
6271 SyncHandle();
6272 }
6273 return;
6274 }
6275 }
6276
6277 #define X_GLsop_GetHistogram 154
6278 void
6279 __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format,
6280 GLenum type, GLvoid * values)
6281 {
6282 __GLXcontext *const gc = __glXGetCurrentContext();
6283 const __GLXattribute *const state = gc->client_state_private;
6284 Display *const dpy = gc->currentDpy;
6285 #ifndef USE_XCB
6286 const GLuint cmdlen = 16;
6287 #endif
6288 if (__builtin_expect(dpy != NULL, 1)) {
6289 #ifdef USE_XCB
6290 xcb_connection_t *c = XGetXCBConnection(dpy);
6291 (void) __glXFlushRenderBuffer(gc, gc->pc);
6292 xcb_glx_get_histogram_reply_t *reply =
6293 xcb_glx_get_histogram_reply(c,
6294 xcb_glx_get_histogram(c,
6295 gc->
6296 currentContextTag,
6297 target, reset,
6298 format, type,
6299 state->
6300 storePack.
6301 swapEndian),
6302 NULL);
6303 (void) memcpy(values, xcb_glx_get_histogram_data(reply),
6304 xcb_glx_get_histogram_data_length(reply) *
6305 sizeof(GLvoid));
6306 free(reply);
6307 #else
6308 GLubyte const *pc =
6309 __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
6310 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6311 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6312 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6313 *(int32_t *) (pc + 12) = 0;
6314 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6315 *(int8_t *) (pc + 13) = reset;
6316 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
6317 GL_TRUE);
6318 UnlockDisplay(dpy);
6319 SyncHandle();
6320 #endif /* USE_XCB */
6321 }
6322 return;
6323 }
6324
6325 #define X_GLvop_GetHistogramEXT 5
6326 void
6327 gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format,
6328 GLenum type, GLvoid * values)
6329 {
6330 __GLXcontext *const gc = __glXGetCurrentContext();
6331
6332 if (gc->driContext) {
6333 CALL_GetHistogram(GET_DISPATCH(),
6334 (target, reset, format, type, values));
6335 } else {
6336 __GLXcontext *const gc = __glXGetCurrentContext();
6337 const __GLXattribute *const state = gc->client_state_private;
6338 Display *const dpy = gc->currentDpy;
6339 const GLuint cmdlen = 16;
6340 if (__builtin_expect(dpy != NULL, 1)) {
6341 GLubyte const *pc =
6342 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6343 X_GLvop_GetHistogramEXT, cmdlen);
6344 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6345 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6346 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6347 *(int32_t *) (pc + 12) = 0;
6348 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6349 *(int8_t *) (pc + 13) = reset;
6350 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
6351 GL_TRUE);
6352 UnlockDisplay(dpy);
6353 SyncHandle();
6354 }
6355 return;
6356 }
6357 }
6358
6359 #define X_GLsop_GetHistogramParameterfv 155
6360 void
6361 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname,
6362 GLfloat * params)
6363 {
6364 __GLXcontext *const gc = __glXGetCurrentContext();
6365 Display *const dpy = gc->currentDpy;
6366 #ifndef USE_XCB
6367 const GLuint cmdlen = 8;
6368 #endif
6369 if (__builtin_expect(dpy != NULL, 1)) {
6370 #ifdef USE_XCB
6371 xcb_connection_t *c = XGetXCBConnection(dpy);
6372 (void) __glXFlushRenderBuffer(gc, gc->pc);
6373 xcb_glx_get_histogram_parameterfv_reply_t *reply =
6374 xcb_glx_get_histogram_parameterfv_reply(c,
6375 xcb_glx_get_histogram_parameterfv
6376 (c, gc->currentContextTag,
6377 target, pname), NULL);
6378 if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 0)
6379 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6380 else
6381 (void) memcpy(params,
6382 xcb_glx_get_histogram_parameterfv_data(reply),
6383 xcb_glx_get_histogram_parameterfv_data_length(reply)
6384 * sizeof(GLfloat));
6385 free(reply);
6386 #else
6387 GLubyte const *pc =
6388 __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv,
6389 cmdlen);
6390 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6391 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6392 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6393 UnlockDisplay(dpy);
6394 SyncHandle();
6395 #endif /* USE_XCB */
6396 }
6397 return;
6398 }
6399
6400 #define X_GLvop_GetHistogramParameterfvEXT 6
6401 void
6402 gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params)
6403 {
6404 __GLXcontext *const gc = __glXGetCurrentContext();
6405
6406 if (gc->driContext) {
6407 CALL_GetHistogramParameterfv(GET_DISPATCH(), (target, pname, params));
6408 } else {
6409 __GLXcontext *const gc = __glXGetCurrentContext();
6410 Display *const dpy = gc->currentDpy;
6411 const GLuint cmdlen = 8;
6412 if (__builtin_expect(dpy != NULL, 1)) {
6413 GLubyte const *pc =
6414 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6415 X_GLvop_GetHistogramParameterfvEXT,
6416 cmdlen);
6417 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6418 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6419 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6420 UnlockDisplay(dpy);
6421 SyncHandle();
6422 }
6423 return;
6424 }
6425 }
6426
6427 #define X_GLsop_GetHistogramParameteriv 156
6428 void
6429 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname,
6430 GLint * params)
6431 {
6432 __GLXcontext *const gc = __glXGetCurrentContext();
6433 Display *const dpy = gc->currentDpy;
6434 #ifndef USE_XCB
6435 const GLuint cmdlen = 8;
6436 #endif
6437 if (__builtin_expect(dpy != NULL, 1)) {
6438 #ifdef USE_XCB
6439 xcb_connection_t *c = XGetXCBConnection(dpy);
6440 (void) __glXFlushRenderBuffer(gc, gc->pc);
6441 xcb_glx_get_histogram_parameteriv_reply_t *reply =
6442 xcb_glx_get_histogram_parameteriv_reply(c,
6443 xcb_glx_get_histogram_parameteriv
6444 (c, gc->currentContextTag,
6445 target, pname), NULL);
6446 if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 0)
6447 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6448 else
6449 (void) memcpy(params,
6450 xcb_glx_get_histogram_parameteriv_data(reply),
6451 xcb_glx_get_histogram_parameteriv_data_length(reply)
6452 * sizeof(GLint));
6453 free(reply);
6454 #else
6455 GLubyte const *pc =
6456 __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv,
6457 cmdlen);
6458 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6459 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6460 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6461 UnlockDisplay(dpy);
6462 SyncHandle();
6463 #endif /* USE_XCB */
6464 }
6465 return;
6466 }
6467
6468 #define X_GLvop_GetHistogramParameterivEXT 7
6469 void
6470 gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params)
6471 {
6472 __GLXcontext *const gc = __glXGetCurrentContext();
6473
6474 if (gc->driContext) {
6475 CALL_GetHistogramParameteriv(GET_DISPATCH(), (target, pname, params));
6476 } else {
6477 __GLXcontext *const gc = __glXGetCurrentContext();
6478 Display *const dpy = gc->currentDpy;
6479 const GLuint cmdlen = 8;
6480 if (__builtin_expect(dpy != NULL, 1)) {
6481 GLubyte const *pc =
6482 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6483 X_GLvop_GetHistogramParameterivEXT,
6484 cmdlen);
6485 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6486 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6487 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6488 UnlockDisplay(dpy);
6489 SyncHandle();
6490 }
6491 return;
6492 }
6493 }
6494
6495 #define X_GLsop_GetMinmax 157
6496 void
6497 __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format,
6498 GLenum type, GLvoid * values)
6499 {
6500 __GLXcontext *const gc = __glXGetCurrentContext();
6501 const __GLXattribute *const state = gc->client_state_private;
6502 Display *const dpy = gc->currentDpy;
6503 #ifndef USE_XCB
6504 const GLuint cmdlen = 16;
6505 #endif
6506 if (__builtin_expect(dpy != NULL, 1)) {
6507 #ifdef USE_XCB
6508 xcb_connection_t *c = XGetXCBConnection(dpy);
6509 (void) __glXFlushRenderBuffer(gc, gc->pc);
6510 xcb_glx_get_minmax_reply_t *reply =
6511 xcb_glx_get_minmax_reply(c,
6512 xcb_glx_get_minmax(c,
6513 gc->currentContextTag,
6514 target, reset, format,
6515 type,
6516 state->storePack.
6517 swapEndian), NULL);
6518 (void) memcpy(values, xcb_glx_get_minmax_data(reply),
6519 xcb_glx_get_minmax_data_length(reply) * sizeof(GLvoid));
6520 free(reply);
6521 #else
6522 GLubyte const *pc =
6523 __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
6524 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6525 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6526 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6527 *(int32_t *) (pc + 12) = 0;
6528 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6529 *(int8_t *) (pc + 13) = reset;
6530 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
6531 GL_FALSE);
6532 UnlockDisplay(dpy);
6533 SyncHandle();
6534 #endif /* USE_XCB */
6535 }
6536 return;
6537 }
6538
6539 #define X_GLvop_GetMinmaxEXT 8
6540 void
6541 gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format,
6542 GLenum type, GLvoid * values)
6543 {
6544 __GLXcontext *const gc = __glXGetCurrentContext();
6545
6546 if (gc->driContext) {
6547 CALL_GetMinmax(GET_DISPATCH(), (target, reset, format, type, values));
6548 } else {
6549 __GLXcontext *const gc = __glXGetCurrentContext();
6550 const __GLXattribute *const state = gc->client_state_private;
6551 Display *const dpy = gc->currentDpy;
6552 const GLuint cmdlen = 16;
6553 if (__builtin_expect(dpy != NULL, 1)) {
6554 GLubyte const *pc =
6555 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6556 X_GLvop_GetMinmaxEXT, cmdlen);
6557 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6558 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6559 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6560 *(int32_t *) (pc + 12) = 0;
6561 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6562 *(int8_t *) (pc + 13) = reset;
6563 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
6564 GL_FALSE);
6565 UnlockDisplay(dpy);
6566 SyncHandle();
6567 }
6568 return;
6569 }
6570 }
6571
6572 #define X_GLsop_GetMinmaxParameterfv 158
6573 void
6574 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname,
6575 GLfloat * params)
6576 {
6577 __GLXcontext *const gc = __glXGetCurrentContext();
6578 Display *const dpy = gc->currentDpy;
6579 #ifndef USE_XCB
6580 const GLuint cmdlen = 8;
6581 #endif
6582 if (__builtin_expect(dpy != NULL, 1)) {
6583 #ifdef USE_XCB
6584 xcb_connection_t *c = XGetXCBConnection(dpy);
6585 (void) __glXFlushRenderBuffer(gc, gc->pc);
6586 xcb_glx_get_minmax_parameterfv_reply_t *reply =
6587 xcb_glx_get_minmax_parameterfv_reply(c,
6588 xcb_glx_get_minmax_parameterfv
6589 (c, gc->currentContextTag,
6590 target, pname), NULL);
6591 if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 0)
6592 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6593 else
6594 (void) memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply),
6595 xcb_glx_get_minmax_parameterfv_data_length(reply) *
6596 sizeof(GLfloat));
6597 free(reply);
6598 #else
6599 GLubyte const *pc =
6600 __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
6601 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6602 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6603 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6604 UnlockDisplay(dpy);
6605 SyncHandle();
6606 #endif /* USE_XCB */
6607 }
6608 return;
6609 }
6610
6611 #define X_GLvop_GetMinmaxParameterfvEXT 9
6612 void
6613 gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params)
6614 {
6615 __GLXcontext *const gc = __glXGetCurrentContext();
6616
6617 if (gc->driContext) {
6618 CALL_GetMinmaxParameterfv(GET_DISPATCH(), (target, pname, params));
6619 } else {
6620 __GLXcontext *const gc = __glXGetCurrentContext();
6621 Display *const dpy = gc->currentDpy;
6622 const GLuint cmdlen = 8;
6623 if (__builtin_expect(dpy != NULL, 1)) {
6624 GLubyte const *pc =
6625 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6626 X_GLvop_GetMinmaxParameterfvEXT,
6627 cmdlen);
6628 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6629 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6630 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6631 UnlockDisplay(dpy);
6632 SyncHandle();
6633 }
6634 return;
6635 }
6636 }
6637
6638 #define X_GLsop_GetMinmaxParameteriv 159
6639 void
6640 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
6641 {
6642 __GLXcontext *const gc = __glXGetCurrentContext();
6643 Display *const dpy = gc->currentDpy;
6644 #ifndef USE_XCB
6645 const GLuint cmdlen = 8;
6646 #endif
6647 if (__builtin_expect(dpy != NULL, 1)) {
6648 #ifdef USE_XCB
6649 xcb_connection_t *c = XGetXCBConnection(dpy);
6650 (void) __glXFlushRenderBuffer(gc, gc->pc);
6651 xcb_glx_get_minmax_parameteriv_reply_t *reply =
6652 xcb_glx_get_minmax_parameteriv_reply(c,
6653 xcb_glx_get_minmax_parameteriv
6654 (c, gc->currentContextTag,
6655 target, pname), NULL);
6656 if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 0)
6657 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6658 else
6659 (void) memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply),
6660 xcb_glx_get_minmax_parameteriv_data_length(reply) *
6661 sizeof(GLint));
6662 free(reply);
6663 #else
6664 GLubyte const *pc =
6665 __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
6666 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6667 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6668 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6669 UnlockDisplay(dpy);
6670 SyncHandle();
6671 #endif /* USE_XCB */
6672 }
6673 return;
6674 }
6675
6676 #define X_GLvop_GetMinmaxParameterivEXT 10
6677 void
6678 gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params)
6679 {
6680 __GLXcontext *const gc = __glXGetCurrentContext();
6681
6682 if (gc->driContext) {
6683 CALL_GetMinmaxParameteriv(GET_DISPATCH(), (target, pname, params));
6684 } else {
6685 __GLXcontext *const gc = __glXGetCurrentContext();
6686 Display *const dpy = gc->currentDpy;
6687 const GLuint cmdlen = 8;
6688 if (__builtin_expect(dpy != NULL, 1)) {
6689 GLubyte const *pc =
6690 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6691 X_GLvop_GetMinmaxParameterivEXT,
6692 cmdlen);
6693 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6694 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6695 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6696 UnlockDisplay(dpy);
6697 SyncHandle();
6698 }
6699 return;
6700 }
6701 }
6702
6703 #define X_GLrop_Histogram 4110
6704 void
6705 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat,
6706 GLboolean sink)
6707 {
6708 __GLXcontext *const gc = __glXGetCurrentContext();
6709 const GLuint cmdlen = 20;
6710 emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
6711 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6712 (void) memcpy((void *) (gc->pc + 8), (void *) (&width), 4);
6713 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
6714 (void) memcpy((void *) (gc->pc + 16), (void *) (&sink), 1);
6715 gc->pc += cmdlen;
6716 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6717 (void) __glXFlushRenderBuffer(gc, gc->pc);
6718 }
6719 }
6720
6721 #define X_GLrop_Minmax 4111
6722 void
6723 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
6724 {
6725 __GLXcontext *const gc = __glXGetCurrentContext();
6726 const GLuint cmdlen = 16;
6727 emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
6728 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6729 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6730 (void) memcpy((void *) (gc->pc + 12), (void *) (&sink), 1);
6731 gc->pc += cmdlen;
6732 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6733 (void) __glXFlushRenderBuffer(gc, gc->pc);
6734 }
6735 }
6736
6737 #define X_GLrop_ResetHistogram 4112
6738 void
6739 __indirect_glResetHistogram(GLenum target)
6740 {
6741 __GLXcontext *const gc = __glXGetCurrentContext();
6742 const GLuint cmdlen = 8;
6743 emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
6744 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6745 gc->pc += cmdlen;
6746 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6747 (void) __glXFlushRenderBuffer(gc, gc->pc);
6748 }
6749 }
6750
6751 #define X_GLrop_ResetMinmax 4113
6752 void
6753 __indirect_glResetMinmax(GLenum target)
6754 {
6755 __GLXcontext *const gc = __glXGetCurrentContext();
6756 const GLuint cmdlen = 8;
6757 emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
6758 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6759 gc->pc += cmdlen;
6760 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6761 (void) __glXFlushRenderBuffer(gc, gc->pc);
6762 }
6763 }
6764
6765 static void
6766 __glx_TexImage_3D4D(unsigned opcode, unsigned dim, GLenum target, GLint level,
6767 GLint internalformat, GLsizei width, GLsizei height,
6768 GLsizei depth, GLsizei extent, GLint border,
6769 GLenum format, GLenum type, const GLvoid * pixels)
6770 {
6771 __GLXcontext *const gc = __glXGetCurrentContext();
6772 const GLuint compsize =
6773 (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
6774 target) : 0;
6775 const GLuint cmdlen = 84 + __GLX_PAD(compsize);
6776 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
6777 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6778 if ((gc->pc + cmdlen) > gc->bufEnd) {
6779 (void) __glXFlushRenderBuffer(gc, gc->pc);
6780 }
6781 emit_header(gc->pc, opcode, cmdlen);
6782 (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
6783 (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
6784 (void) memcpy((void *) (gc->pc + 48), (void *) (&internalformat),
6785 4);
6786 (void) memcpy((void *) (gc->pc + 52), (void *) (&width), 4);
6787 (void) memcpy((void *) (gc->pc + 56), (void *) (&height), 4);
6788 (void) memcpy((void *) (gc->pc + 60), (void *) (&depth), 4);
6789 (void) memcpy((void *) (gc->pc + 64), (void *) (&extent), 4);
6790 (void) memcpy((void *) (gc->pc + 68), (void *) (&border), 4);
6791 (void) memcpy((void *) (gc->pc + 72), (void *) (&format), 4);
6792 (void) memcpy((void *) (gc->pc + 76), (void *) (&type), 4);
6793 (void) memcpy((void *) (gc->pc + 80),
6794 (void *) ((pixels == NULL) ? one : zero), 4);
6795 if (compsize > 0) {
6796 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
6797 pixels, gc->pc + 84, gc->pc + 4);
6798 } else {
6799 (void) memcpy(gc->pc + 4, default_pixel_store_4D,
6800 default_pixel_store_4D_size);
6801 }
6802 gc->pc += cmdlen;
6803 if (gc->pc > gc->limit) {
6804 (void) __glXFlushRenderBuffer(gc, gc->pc);
6805 }
6806 } else {
6807 const GLint op = opcode;
6808 const GLuint cmdlenLarge = cmdlen + 4;
6809 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
6810 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
6811 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
6812 (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
6813 (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
6814 (void) memcpy((void *) (pc + 52), (void *) (&internalformat), 4);
6815 (void) memcpy((void *) (pc + 56), (void *) (&width), 4);
6816 (void) memcpy((void *) (pc + 60), (void *) (&height), 4);
6817 (void) memcpy((void *) (pc + 64), (void *) (&depth), 4);
6818 (void) memcpy((void *) (pc + 68), (void *) (&extent), 4);
6819 (void) memcpy((void *) (pc + 72), (void *) (&border), 4);
6820 (void) memcpy((void *) (pc + 76), (void *) (&format), 4);
6821 (void) memcpy((void *) (pc + 80), (void *) (&type), 4);
6822 (void) memcpy((void *) (pc + 84), zero, 4);
6823 __glXSendLargeImage(gc, compsize, dim, width, height, depth,
6824 format, type, pixels, pc + 88, pc + 8);
6825 }
6826 }
6827 }
6828
6829 #define X_GLrop_TexImage3D 4114
6830 void
6831 __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat,
6832 GLsizei width, GLsizei height, GLsizei depth,
6833 GLint border, GLenum format, GLenum type,
6834 const GLvoid * pixels)
6835 {
6836 __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat,
6837 width, height, depth, 1, border, format, type,
6838 pixels);
6839 }
6840
6841 static void
6842 __glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target,
6843 GLint level, GLint xoffset, GLint yoffset,
6844 GLint zoffset, GLint woffset, GLsizei width,
6845 GLsizei height, GLsizei depth, GLsizei extent,
6846 GLenum format, GLenum type, const GLvoid * pixels)
6847 {
6848 __GLXcontext *const gc = __glXGetCurrentContext();
6849 const GLuint compsize =
6850 (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
6851 target) : 0;
6852 const GLuint cmdlen = 92 + __GLX_PAD(compsize);
6853 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
6854 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6855 if ((gc->pc + cmdlen) > gc->bufEnd) {
6856 (void) __glXFlushRenderBuffer(gc, gc->pc);
6857 }
6858 emit_header(gc->pc, opcode, cmdlen);
6859 (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
6860 (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
6861 (void) memcpy((void *) (gc->pc + 48), (void *) (&xoffset), 4);
6862 (void) memcpy((void *) (gc->pc + 52), (void *) (&yoffset), 4);
6863 (void) memcpy((void *) (gc->pc + 56), (void *) (&zoffset), 4);
6864 (void) memcpy((void *) (gc->pc + 60), (void *) (&woffset), 4);
6865 (void) memcpy((void *) (gc->pc + 64), (void *) (&width), 4);
6866 (void) memcpy((void *) (gc->pc + 68), (void *) (&height), 4);
6867 (void) memcpy((void *) (gc->pc + 72), (void *) (&depth), 4);
6868 (void) memcpy((void *) (gc->pc + 76), (void *) (&extent), 4);
6869 (void) memcpy((void *) (gc->pc + 80), (void *) (&format), 4);
6870 (void) memcpy((void *) (gc->pc + 84), (void *) (&type), 4);
6871 (void) memset((void *) (gc->pc + 88), 0, 4);
6872 if (compsize > 0) {
6873 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
6874 pixels, gc->pc + 92, gc->pc + 4);
6875 } else {
6876 (void) memcpy(gc->pc + 4, default_pixel_store_4D,
6877 default_pixel_store_4D_size);
6878 }
6879 gc->pc += cmdlen;
6880 if (gc->pc > gc->limit) {
6881 (void) __glXFlushRenderBuffer(gc, gc->pc);
6882 }
6883 } else {
6884 const GLint op = opcode;
6885 const GLuint cmdlenLarge = cmdlen + 4;
6886 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
6887 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
6888 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
6889 (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
6890 (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
6891 (void) memcpy((void *) (pc + 52), (void *) (&xoffset), 4);
6892 (void) memcpy((void *) (pc + 56), (void *) (&yoffset), 4);
6893 (void) memcpy((void *) (pc + 60), (void *) (&zoffset), 4);
6894 (void) memcpy((void *) (pc + 64), (void *) (&woffset), 4);
6895 (void) memcpy((void *) (pc + 68), (void *) (&width), 4);
6896 (void) memcpy((void *) (pc + 72), (void *) (&height), 4);
6897 (void) memcpy((void *) (pc + 76), (void *) (&depth), 4);
6898 (void) memcpy((void *) (pc + 80), (void *) (&extent), 4);
6899 (void) memcpy((void *) (pc + 84), (void *) (&format), 4);
6900 (void) memcpy((void *) (pc + 88), (void *) (&type), 4);
6901 (void) memset((void *) (pc + 92), 0, 4);
6902 __glXSendLargeImage(gc, compsize, dim, width, height, depth,
6903 format, type, pixels, pc + 96, pc + 8);
6904 }
6905 }
6906 }
6907
6908 #define X_GLrop_TexSubImage3D 4115
6909 void
6910 __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
6911 GLint yoffset, GLint zoffset, GLsizei width,
6912 GLsizei height, GLsizei depth, GLenum format,
6913 GLenum type, const GLvoid * pixels)
6914 {
6915 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset,
6916 yoffset, zoffset, 1, width, height, depth, 1,
6917 format, type, pixels);
6918 }
6919
6920 #define X_GLrop_CopyTexSubImage3D 4123
6921 void
6922 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
6923 GLint yoffset, GLint zoffset, GLint x, GLint y,
6924 GLsizei width, GLsizei height)
6925 {
6926 __GLXcontext *const gc = __glXGetCurrentContext();
6927 const GLuint cmdlen = 40;
6928 emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
6929 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6930 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
6931 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
6932 (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
6933 (void) memcpy((void *) (gc->pc + 20), (void *) (&zoffset), 4);
6934 (void) memcpy((void *) (gc->pc + 24), (void *) (&x), 4);
6935 (void) memcpy((void *) (gc->pc + 28), (void *) (&y), 4);
6936 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
6937 (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
6938 gc->pc += cmdlen;
6939 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6940 (void) __glXFlushRenderBuffer(gc, gc->pc);
6941 }
6942 }
6943
6944 #define X_GLrop_ActiveTextureARB 197
6945 void
6946 __indirect_glActiveTextureARB(GLenum texture)
6947 {
6948 __GLXcontext *const gc = __glXGetCurrentContext();
6949 const GLuint cmdlen = 8;
6950 emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
6951 (void) memcpy((void *) (gc->pc + 4), (void *) (&texture), 4);
6952 gc->pc += cmdlen;
6953 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6954 (void) __glXFlushRenderBuffer(gc, gc->pc);
6955 }
6956 }
6957
6958 #define X_GLrop_MultiTexCoord1dvARB 198
6959 void
6960 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
6961 {
6962 __GLXcontext *const gc = __glXGetCurrentContext();
6963 const GLuint cmdlen = 16;
6964 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
6965 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
6966 (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
6967 gc->pc += cmdlen;
6968 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6969 (void) __glXFlushRenderBuffer(gc, gc->pc);
6970 }
6971 }
6972
6973 #define X_GLrop_MultiTexCoord1dvARB 198
6974 void
6975 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
6976 {
6977 __GLXcontext *const gc = __glXGetCurrentContext();
6978 const GLuint cmdlen = 16;
6979 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
6980 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 8);
6981 (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
6982 gc->pc += cmdlen;
6983 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6984 (void) __glXFlushRenderBuffer(gc, gc->pc);
6985 }
6986 }
6987
6988 #define X_GLrop_MultiTexCoord1fvARB 199
6989 void
6990 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
6991 {
6992 __GLXcontext *const gc = __glXGetCurrentContext();
6993 const GLuint cmdlen = 12;
6994 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
6995 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6996 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
6997 gc->pc += cmdlen;
6998 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6999 (void) __glXFlushRenderBuffer(gc, gc->pc);
7000 }
7001 }
7002
7003 #define X_GLrop_MultiTexCoord1fvARB 199
7004 void
7005 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
7006 {
7007 __GLXcontext *const gc = __glXGetCurrentContext();
7008 const GLuint cmdlen = 12;
7009 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
7010 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7011 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7012 gc->pc += cmdlen;
7013 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7014 (void) __glXFlushRenderBuffer(gc, gc->pc);
7015 }
7016 }
7017
7018 #define X_GLrop_MultiTexCoord1ivARB 200
7019 void
7020 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
7021 {
7022 __GLXcontext *const gc = __glXGetCurrentContext();
7023 const GLuint cmdlen = 12;
7024 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
7025 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7026 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7027 gc->pc += cmdlen;
7028 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7029 (void) __glXFlushRenderBuffer(gc, gc->pc);
7030 }
7031 }
7032
7033 #define X_GLrop_MultiTexCoord1ivARB 200
7034 void
7035 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
7036 {
7037 __GLXcontext *const gc = __glXGetCurrentContext();
7038 const GLuint cmdlen = 12;
7039 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
7040 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7041 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7042 gc->pc += cmdlen;
7043 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7044 (void) __glXFlushRenderBuffer(gc, gc->pc);
7045 }
7046 }
7047
7048 #define X_GLrop_MultiTexCoord1svARB 201
7049 void
7050 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
7051 {
7052 __GLXcontext *const gc = __glXGetCurrentContext();
7053 const GLuint cmdlen = 12;
7054 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
7055 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7056 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7057 gc->pc += cmdlen;
7058 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7059 (void) __glXFlushRenderBuffer(gc, gc->pc);
7060 }
7061 }
7062
7063 #define X_GLrop_MultiTexCoord1svARB 201
7064 void
7065 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
7066 {
7067 __GLXcontext *const gc = __glXGetCurrentContext();
7068 const GLuint cmdlen = 12;
7069 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
7070 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7071 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
7072 gc->pc += cmdlen;
7073 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7074 (void) __glXFlushRenderBuffer(gc, gc->pc);
7075 }
7076 }
7077
7078 #define X_GLrop_MultiTexCoord2dvARB 202
7079 void
7080 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
7081 {
7082 __GLXcontext *const gc = __glXGetCurrentContext();
7083 const GLuint cmdlen = 24;
7084 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
7085 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7086 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7087 (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
7088 gc->pc += cmdlen;
7089 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7090 (void) __glXFlushRenderBuffer(gc, gc->pc);
7091 }
7092 }
7093
7094 #define X_GLrop_MultiTexCoord2dvARB 202
7095 void
7096 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
7097 {
7098 __GLXcontext *const gc = __glXGetCurrentContext();
7099 const GLuint cmdlen = 24;
7100 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
7101 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 16);
7102 (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
7103 gc->pc += cmdlen;
7104 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7105 (void) __glXFlushRenderBuffer(gc, gc->pc);
7106 }
7107 }
7108
7109 #define X_GLrop_MultiTexCoord2fvARB 203
7110 void
7111 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
7112 {
7113 __GLXcontext *const gc = __glXGetCurrentContext();
7114 const GLuint cmdlen = 16;
7115 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
7116 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7117 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7118 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7119 gc->pc += cmdlen;
7120 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7121 (void) __glXFlushRenderBuffer(gc, gc->pc);
7122 }
7123 }
7124
7125 #define X_GLrop_MultiTexCoord2fvARB 203
7126 void
7127 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
7128 {
7129 __GLXcontext *const gc = __glXGetCurrentContext();
7130 const GLuint cmdlen = 16;
7131 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
7132 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7133 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7134 gc->pc += cmdlen;
7135 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7136 (void) __glXFlushRenderBuffer(gc, gc->pc);
7137 }
7138 }
7139
7140 #define X_GLrop_MultiTexCoord2ivARB 204
7141 void
7142 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
7143 {
7144 __GLXcontext *const gc = __glXGetCurrentContext();
7145 const GLuint cmdlen = 16;
7146 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
7147 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7148 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7149 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7150 gc->pc += cmdlen;
7151 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7152 (void) __glXFlushRenderBuffer(gc, gc->pc);
7153 }
7154 }
7155
7156 #define X_GLrop_MultiTexCoord2ivARB 204
7157 void
7158 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
7159 {
7160 __GLXcontext *const gc = __glXGetCurrentContext();
7161 const GLuint cmdlen = 16;
7162 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
7163 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7164 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7165 gc->pc += cmdlen;
7166 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7167 (void) __glXFlushRenderBuffer(gc, gc->pc);
7168 }
7169 }
7170
7171 #define X_GLrop_MultiTexCoord2svARB 205
7172 void
7173 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
7174 {
7175 __GLXcontext *const gc = __glXGetCurrentContext();
7176 const GLuint cmdlen = 12;
7177 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
7178 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7179 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7180 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7181 gc->pc += cmdlen;
7182 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7183 (void) __glXFlushRenderBuffer(gc, gc->pc);
7184 }
7185 }
7186
7187 #define X_GLrop_MultiTexCoord2svARB 205
7188 void
7189 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
7190 {
7191 __GLXcontext *const gc = __glXGetCurrentContext();
7192 const GLuint cmdlen = 12;
7193 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
7194 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7195 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7196 gc->pc += cmdlen;
7197 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7198 (void) __glXFlushRenderBuffer(gc, gc->pc);
7199 }
7200 }
7201
7202 #define X_GLrop_MultiTexCoord3dvARB 206
7203 void
7204 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t,
7205 GLdouble r)
7206 {
7207 __GLXcontext *const gc = __glXGetCurrentContext();
7208 const GLuint cmdlen = 32;
7209 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
7210 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7211 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7212 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
7213 (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
7214 gc->pc += cmdlen;
7215 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7216 (void) __glXFlushRenderBuffer(gc, gc->pc);
7217 }
7218 }
7219
7220 #define X_GLrop_MultiTexCoord3dvARB 206
7221 void
7222 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
7223 {
7224 __GLXcontext *const gc = __glXGetCurrentContext();
7225 const GLuint cmdlen = 32;
7226 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
7227 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 24);
7228 (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
7229 gc->pc += cmdlen;
7230 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7231 (void) __glXFlushRenderBuffer(gc, gc->pc);
7232 }
7233 }
7234
7235 #define X_GLrop_MultiTexCoord3fvARB 207
7236 void
7237 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t,
7238 GLfloat r)
7239 {
7240 __GLXcontext *const gc = __glXGetCurrentContext();
7241 const GLuint cmdlen = 20;
7242 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
7243 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7244 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7245 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7246 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7247 gc->pc += cmdlen;
7248 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7249 (void) __glXFlushRenderBuffer(gc, gc->pc);
7250 }
7251 }
7252
7253 #define X_GLrop_MultiTexCoord3fvARB 207
7254 void
7255 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
7256 {
7257 __GLXcontext *const gc = __glXGetCurrentContext();
7258 const GLuint cmdlen = 20;
7259 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
7260 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7261 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7262 gc->pc += cmdlen;
7263 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7264 (void) __glXFlushRenderBuffer(gc, gc->pc);
7265 }
7266 }
7267
7268 #define X_GLrop_MultiTexCoord3ivARB 208
7269 void
7270 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
7271 {
7272 __GLXcontext *const gc = __glXGetCurrentContext();
7273 const GLuint cmdlen = 20;
7274 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
7275 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7276 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7277 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7278 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7279 gc->pc += cmdlen;
7280 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7281 (void) __glXFlushRenderBuffer(gc, gc->pc);
7282 }
7283 }
7284
7285 #define X_GLrop_MultiTexCoord3ivARB 208
7286 void
7287 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
7288 {
7289 __GLXcontext *const gc = __glXGetCurrentContext();
7290 const GLuint cmdlen = 20;
7291 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
7292 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7293 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7294 gc->pc += cmdlen;
7295 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7296 (void) __glXFlushRenderBuffer(gc, gc->pc);
7297 }
7298 }
7299
7300 #define X_GLrop_MultiTexCoord3svARB 209
7301 void
7302 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t,
7303 GLshort r)
7304 {
7305 __GLXcontext *const gc = __glXGetCurrentContext();
7306 const GLuint cmdlen = 16;
7307 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
7308 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7309 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7310 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7311 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
7312 gc->pc += cmdlen;
7313 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7314 (void) __glXFlushRenderBuffer(gc, gc->pc);
7315 }
7316 }
7317
7318 #define X_GLrop_MultiTexCoord3svARB 209
7319 void
7320 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
7321 {
7322 __GLXcontext *const gc = __glXGetCurrentContext();
7323 const GLuint cmdlen = 16;
7324 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
7325 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7326 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
7327 gc->pc += cmdlen;
7328 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7329 (void) __glXFlushRenderBuffer(gc, gc->pc);
7330 }
7331 }
7332
7333 #define X_GLrop_MultiTexCoord4dvARB 210
7334 void
7335 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t,
7336 GLdouble r, GLdouble q)
7337 {
7338 __GLXcontext *const gc = __glXGetCurrentContext();
7339 const GLuint cmdlen = 40;
7340 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
7341 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7342 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7343 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
7344 (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
7345 (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
7346 gc->pc += cmdlen;
7347 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7348 (void) __glXFlushRenderBuffer(gc, gc->pc);
7349 }
7350 }
7351
7352 #define X_GLrop_MultiTexCoord4dvARB 210
7353 void
7354 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
7355 {
7356 __GLXcontext *const gc = __glXGetCurrentContext();
7357 const GLuint cmdlen = 40;
7358 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
7359 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
7360 (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
7361 gc->pc += cmdlen;
7362 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7363 (void) __glXFlushRenderBuffer(gc, gc->pc);
7364 }
7365 }
7366
7367 #define X_GLrop_MultiTexCoord4fvARB 211
7368 void
7369 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t,
7370 GLfloat r, GLfloat q)
7371 {
7372 __GLXcontext *const gc = __glXGetCurrentContext();
7373 const GLuint cmdlen = 24;
7374 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
7375 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7376 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7377 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7378 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7379 (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
7380 gc->pc += cmdlen;
7381 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7382 (void) __glXFlushRenderBuffer(gc, gc->pc);
7383 }
7384 }
7385
7386 #define X_GLrop_MultiTexCoord4fvARB 211
7387 void
7388 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
7389 {
7390 __GLXcontext *const gc = __glXGetCurrentContext();
7391 const GLuint cmdlen = 24;
7392 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
7393 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7394 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7395 gc->pc += cmdlen;
7396 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7397 (void) __glXFlushRenderBuffer(gc, gc->pc);
7398 }
7399 }
7400
7401 #define X_GLrop_MultiTexCoord4ivARB 212
7402 void
7403 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r,
7404 GLint q)
7405 {
7406 __GLXcontext *const gc = __glXGetCurrentContext();
7407 const GLuint cmdlen = 24;
7408 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
7409 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7410 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7411 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7412 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7413 (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
7414 gc->pc += cmdlen;
7415 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7416 (void) __glXFlushRenderBuffer(gc, gc->pc);
7417 }
7418 }
7419
7420 #define X_GLrop_MultiTexCoord4ivARB 212
7421 void
7422 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
7423 {
7424 __GLXcontext *const gc = __glXGetCurrentContext();
7425 const GLuint cmdlen = 24;
7426 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
7427 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7428 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7429 gc->pc += cmdlen;
7430 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7431 (void) __glXFlushRenderBuffer(gc, gc->pc);
7432 }
7433 }
7434
7435 #define X_GLrop_MultiTexCoord4svARB 213
7436 void
7437 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t,
7438 GLshort r, GLshort q)
7439 {
7440 __GLXcontext *const gc = __glXGetCurrentContext();
7441 const GLuint cmdlen = 16;
7442 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
7443 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7444 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7445 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7446 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
7447 (void) memcpy((void *) (gc->pc + 14), (void *) (&q), 2);
7448 gc->pc += cmdlen;
7449 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7450 (void) __glXFlushRenderBuffer(gc, gc->pc);
7451 }
7452 }
7453
7454 #define X_GLrop_MultiTexCoord4svARB 213
7455 void
7456 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
7457 {
7458 __GLXcontext *const gc = __glXGetCurrentContext();
7459 const GLuint cmdlen = 16;
7460 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
7461 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7462 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7463 gc->pc += cmdlen;
7464 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7465 (void) __glXFlushRenderBuffer(gc, gc->pc);
7466 }
7467 }
7468
7469 #define X_GLrop_SampleCoverageARB 229
7470 void
7471 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
7472 {
7473 __GLXcontext *const gc = __glXGetCurrentContext();
7474 const GLuint cmdlen = 12;
7475 emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
7476 (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
7477 (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
7478 gc->pc += cmdlen;
7479 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7480 (void) __glXFlushRenderBuffer(gc, gc->pc);
7481 }
7482 }
7483
7484 #define X_GLvop_GetProgramStringARB 1308
7485 void
7486 __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
7487 {
7488 __GLXcontext *const gc = __glXGetCurrentContext();
7489 Display *const dpy = gc->currentDpy;
7490 const GLuint cmdlen = 8;
7491 if (__builtin_expect(dpy != NULL, 1)) {
7492 GLubyte const *pc =
7493 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
7494 X_GLvop_GetProgramStringARB, cmdlen);
7495 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
7496 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
7497 (void) __glXReadReply(dpy, 1, string, GL_TRUE);
7498 UnlockDisplay(dpy);
7499 SyncHandle();
7500 }
7501 return;
7502 }
7503
7504 #define X_GLvop_GetProgramivARB 1307
7505 void
7506 __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
7507 {
7508 __GLXcontext *const gc = __glXGetCurrentContext();
7509 Display *const dpy = gc->currentDpy;
7510 const GLuint cmdlen = 8;
7511 if (__builtin_expect(dpy != NULL, 1)) {
7512 GLubyte const *pc =
7513 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
7514 X_GLvop_GetProgramivARB, cmdlen);
7515 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
7516 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
7517 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7518 UnlockDisplay(dpy);
7519 SyncHandle();
7520 }
7521 return;
7522 }
7523
7524 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7525 void
7526 __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x,
7527 GLdouble y, GLdouble z, GLdouble w)
7528 {
7529 __GLXcontext *const gc = __glXGetCurrentContext();
7530 const GLuint cmdlen = 44;
7531 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
7532 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7533 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7534 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
7535 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
7536 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
7537 (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
7538 gc->pc += cmdlen;
7539 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7540 (void) __glXFlushRenderBuffer(gc, gc->pc);
7541 }
7542 }
7543
7544 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7545 void
7546 __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index,
7547 const GLdouble * params)
7548 {
7549 __GLXcontext *const gc = __glXGetCurrentContext();
7550 const GLuint cmdlen = 44;
7551 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
7552 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7553 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7554 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
7555 gc->pc += cmdlen;
7556 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7557 (void) __glXFlushRenderBuffer(gc, gc->pc);
7558 }
7559 }
7560
7561 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7562 void
7563 __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x,
7564 GLfloat y, GLfloat z, GLfloat w)
7565 {
7566 __GLXcontext *const gc = __glXGetCurrentContext();
7567 const GLuint cmdlen = 28;
7568 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
7569 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7570 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7571 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
7572 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
7573 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
7574 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
7575 gc->pc += cmdlen;
7576 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7577 (void) __glXFlushRenderBuffer(gc, gc->pc);
7578 }
7579 }
7580
7581 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7582 void
7583 __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index,
7584 const GLfloat * params)
7585 {
7586 __GLXcontext *const gc = __glXGetCurrentContext();
7587 const GLuint cmdlen = 28;
7588 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
7589 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7590 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7591 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
7592 gc->pc += cmdlen;
7593 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7594 (void) __glXFlushRenderBuffer(gc, gc->pc);
7595 }
7596 }
7597
7598 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7599 void
7600 __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index,
7601 GLdouble x, GLdouble y, GLdouble z,
7602 GLdouble w)
7603 {
7604 __GLXcontext *const gc = __glXGetCurrentContext();
7605 const GLuint cmdlen = 44;
7606 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7607 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7608 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7609 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
7610 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
7611 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
7612 (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
7613 gc->pc += cmdlen;
7614 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7615 (void) __glXFlushRenderBuffer(gc, gc->pc);
7616 }
7617 }
7618
7619 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7620 void
7621 __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index,
7622 const GLdouble * params)
7623 {
7624 __GLXcontext *const gc = __glXGetCurrentContext();
7625 const GLuint cmdlen = 44;
7626 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7627 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7628 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7629 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
7630 gc->pc += cmdlen;
7631 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7632 (void) __glXFlushRenderBuffer(gc, gc->pc);
7633 }
7634 }
7635
7636 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7637 void
7638 __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index,
7639 GLfloat x, GLfloat y, GLfloat z,
7640 GLfloat w)
7641 {
7642 __GLXcontext *const gc = __glXGetCurrentContext();
7643 const GLuint cmdlen = 28;
7644 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7645 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7646 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7647 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
7648 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
7649 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
7650 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
7651 gc->pc += cmdlen;
7652 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7653 (void) __glXFlushRenderBuffer(gc, gc->pc);
7654 }
7655 }
7656
7657 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7658 void
7659 __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index,
7660 const GLfloat * params)
7661 {
7662 __GLXcontext *const gc = __glXGetCurrentContext();
7663 const GLuint cmdlen = 28;
7664 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7665 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7666 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7667 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
7668 gc->pc += cmdlen;
7669 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7670 (void) __glXFlushRenderBuffer(gc, gc->pc);
7671 }
7672 }
7673
7674 #define X_GLrop_ProgramStringARB 4217
7675 void
7676 __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len,
7677 const GLvoid * string)
7678 {
7679 __GLXcontext *const gc = __glXGetCurrentContext();
7680 const GLuint cmdlen = 16 + __GLX_PAD(len);
7681 if (len < 0) {
7682 __glXSetError(gc, GL_INVALID_VALUE);
7683 return;
7684 }
7685 if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
7686 if (cmdlen <= gc->maxSmallRenderCommandSize) {
7687 if ((gc->pc + cmdlen) > gc->bufEnd) {
7688 (void) __glXFlushRenderBuffer(gc, gc->pc);
7689 }
7690 emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
7691 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7692 (void) memcpy((void *) (gc->pc + 8), (void *) (&format), 4);
7693 (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
7694 (void) memcpy((void *) (gc->pc + 16), (void *) (string), len);
7695 gc->pc += cmdlen;
7696 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7697 (void) __glXFlushRenderBuffer(gc, gc->pc);
7698 }
7699 } else {
7700 const GLint op = X_GLrop_ProgramStringARB;
7701 const GLuint cmdlenLarge = cmdlen + 4;
7702 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
7703 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
7704 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
7705 (void) memcpy((void *) (pc + 8), (void *) (&target), 4);
7706 (void) memcpy((void *) (pc + 12), (void *) (&format), 4);
7707 (void) memcpy((void *) (pc + 16), (void *) (&len), 4);
7708 __glXSendLargeCommand(gc, pc, 20, string, len);
7709 }
7710 }
7711 }
7712
7713 #define X_GLrop_VertexAttrib1dvARB 4197
7714 void
7715 __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
7716 {
7717 __GLXcontext *const gc = __glXGetCurrentContext();
7718 const GLuint cmdlen = 16;
7719 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
7720 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7721 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7722 gc->pc += cmdlen;
7723 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7724 (void) __glXFlushRenderBuffer(gc, gc->pc);
7725 }
7726 }
7727
7728 #define X_GLrop_VertexAttrib1dvARB 4197
7729 void
7730 __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
7731 {
7732 __GLXcontext *const gc = __glXGetCurrentContext();
7733 const GLuint cmdlen = 16;
7734 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
7735 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7736 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7737 gc->pc += cmdlen;
7738 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7739 (void) __glXFlushRenderBuffer(gc, gc->pc);
7740 }
7741 }
7742
7743 #define X_GLrop_VertexAttrib1fvARB 4193
7744 void
7745 __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
7746 {
7747 __GLXcontext *const gc = __glXGetCurrentContext();
7748 const GLuint cmdlen = 12;
7749 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
7750 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7751 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7752 gc->pc += cmdlen;
7753 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7754 (void) __glXFlushRenderBuffer(gc, gc->pc);
7755 }
7756 }
7757
7758 #define X_GLrop_VertexAttrib1fvARB 4193
7759 void
7760 __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
7761 {
7762 __GLXcontext *const gc = __glXGetCurrentContext();
7763 const GLuint cmdlen = 12;
7764 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
7765 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7766 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7767 gc->pc += cmdlen;
7768 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7769 (void) __glXFlushRenderBuffer(gc, gc->pc);
7770 }
7771 }
7772
7773 #define X_GLrop_VertexAttrib1svARB 4189
7774 void
7775 __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
7776 {
7777 __GLXcontext *const gc = __glXGetCurrentContext();
7778 const GLuint cmdlen = 12;
7779 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
7780 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7781 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7782 gc->pc += cmdlen;
7783 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7784 (void) __glXFlushRenderBuffer(gc, gc->pc);
7785 }
7786 }
7787
7788 #define X_GLrop_VertexAttrib1svARB 4189
7789 void
7790 __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
7791 {
7792 __GLXcontext *const gc = __glXGetCurrentContext();
7793 const GLuint cmdlen = 12;
7794 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
7795 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7796 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
7797 gc->pc += cmdlen;
7798 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7799 (void) __glXFlushRenderBuffer(gc, gc->pc);
7800 }
7801 }
7802
7803 #define X_GLrop_VertexAttrib2dvARB 4198
7804 void
7805 __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
7806 {
7807 __GLXcontext *const gc = __glXGetCurrentContext();
7808 const GLuint cmdlen = 24;
7809 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
7810 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7811 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7812 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
7813 gc->pc += cmdlen;
7814 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7815 (void) __glXFlushRenderBuffer(gc, gc->pc);
7816 }
7817 }
7818
7819 #define X_GLrop_VertexAttrib2dvARB 4198
7820 void
7821 __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
7822 {
7823 __GLXcontext *const gc = __glXGetCurrentContext();
7824 const GLuint cmdlen = 24;
7825 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
7826 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7827 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7828 gc->pc += cmdlen;
7829 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7830 (void) __glXFlushRenderBuffer(gc, gc->pc);
7831 }
7832 }
7833
7834 #define X_GLrop_VertexAttrib2fvARB 4194
7835 void
7836 __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
7837 {
7838 __GLXcontext *const gc = __glXGetCurrentContext();
7839 const GLuint cmdlen = 16;
7840 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
7841 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7842 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7843 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
7844 gc->pc += cmdlen;
7845 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7846 (void) __glXFlushRenderBuffer(gc, gc->pc);
7847 }
7848 }
7849
7850 #define X_GLrop_VertexAttrib2fvARB 4194
7851 void
7852 __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
7853 {
7854 __GLXcontext *const gc = __glXGetCurrentContext();
7855 const GLuint cmdlen = 16;
7856 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
7857 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7858 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7859 gc->pc += cmdlen;
7860 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7861 (void) __glXFlushRenderBuffer(gc, gc->pc);
7862 }
7863 }
7864
7865 #define X_GLrop_VertexAttrib2svARB 4190
7866 void
7867 __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
7868 {
7869 __GLXcontext *const gc = __glXGetCurrentContext();
7870 const GLuint cmdlen = 12;
7871 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
7872 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7873 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7874 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
7875 gc->pc += cmdlen;
7876 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7877 (void) __glXFlushRenderBuffer(gc, gc->pc);
7878 }
7879 }
7880
7881 #define X_GLrop_VertexAttrib2svARB 4190
7882 void
7883 __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
7884 {
7885 __GLXcontext *const gc = __glXGetCurrentContext();
7886 const GLuint cmdlen = 12;
7887 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
7888 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7889 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7890 gc->pc += cmdlen;
7891 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7892 (void) __glXFlushRenderBuffer(gc, gc->pc);
7893 }
7894 }
7895
7896 #define X_GLrop_VertexAttrib3dvARB 4199
7897 void
7898 __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y,
7899 GLdouble z)
7900 {
7901 __GLXcontext *const gc = __glXGetCurrentContext();
7902 const GLuint cmdlen = 32;
7903 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
7904 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7905 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7906 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
7907 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
7908 gc->pc += cmdlen;
7909 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7910 (void) __glXFlushRenderBuffer(gc, gc->pc);
7911 }
7912 }
7913
7914 #define X_GLrop_VertexAttrib3dvARB 4199
7915 void
7916 __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
7917 {
7918 __GLXcontext *const gc = __glXGetCurrentContext();
7919 const GLuint cmdlen = 32;
7920 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
7921 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7922 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
7923 gc->pc += cmdlen;
7924 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7925 (void) __glXFlushRenderBuffer(gc, gc->pc);
7926 }
7927 }
7928
7929 #define X_GLrop_VertexAttrib3fvARB 4195
7930 void
7931 __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
7932 {
7933 __GLXcontext *const gc = __glXGetCurrentContext();
7934 const GLuint cmdlen = 20;
7935 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
7936 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7937 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7938 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
7939 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
7940 gc->pc += cmdlen;
7941 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7942 (void) __glXFlushRenderBuffer(gc, gc->pc);
7943 }
7944 }
7945
7946 #define X_GLrop_VertexAttrib3fvARB 4195
7947 void
7948 __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
7949 {
7950 __GLXcontext *const gc = __glXGetCurrentContext();
7951 const GLuint cmdlen = 20;
7952 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
7953 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7954 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7955 gc->pc += cmdlen;
7956 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7957 (void) __glXFlushRenderBuffer(gc, gc->pc);
7958 }
7959 }
7960
7961 #define X_GLrop_VertexAttrib3svARB 4191
7962 void
7963 __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
7964 {
7965 __GLXcontext *const gc = __glXGetCurrentContext();
7966 const GLuint cmdlen = 16;
7967 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
7968 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7969 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7970 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
7971 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
7972 gc->pc += cmdlen;
7973 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7974 (void) __glXFlushRenderBuffer(gc, gc->pc);
7975 }
7976 }
7977
7978 #define X_GLrop_VertexAttrib3svARB 4191
7979 void
7980 __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
7981 {
7982 __GLXcontext *const gc = __glXGetCurrentContext();
7983 const GLuint cmdlen = 16;
7984 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
7985 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7986 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
7987 gc->pc += cmdlen;
7988 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7989 (void) __glXFlushRenderBuffer(gc, gc->pc);
7990 }
7991 }
7992
7993 #define X_GLrop_VertexAttrib4NbvARB 4235
7994 void
7995 __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte *v)
7996 {
7997 __GLXcontext *const gc = __glXGetCurrentContext();
7998 const GLuint cmdlen = 12;
7999 emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
8000 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8001 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8002 gc->pc += cmdlen;
8003 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8004 (void) __glXFlushRenderBuffer(gc, gc->pc);
8005 }
8006 }
8007
8008 #define X_GLrop_VertexAttrib4NivARB 4237
8009 void
8010 __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
8011 {
8012 __GLXcontext *const gc = __glXGetCurrentContext();
8013 const GLuint cmdlen = 24;
8014 emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
8015 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8016 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8017 gc->pc += cmdlen;
8018 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8019 (void) __glXFlushRenderBuffer(gc, gc->pc);
8020 }
8021 }
8022
8023 #define X_GLrop_VertexAttrib4NsvARB 4236
8024 void
8025 __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
8026 {
8027 __GLXcontext *const gc = __glXGetCurrentContext();
8028 const GLuint cmdlen = 16;
8029 emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
8030 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8031 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8032 gc->pc += cmdlen;
8033 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8034 (void) __glXFlushRenderBuffer(gc, gc->pc);
8035 }
8036 }
8037
8038 #define X_GLrop_VertexAttrib4NubvARB 4201
8039 void
8040 __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y,
8041 GLubyte z, GLubyte w)
8042 {
8043 __GLXcontext *const gc = __glXGetCurrentContext();
8044 const GLuint cmdlen = 12;
8045 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
8046 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8047 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
8048 (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
8049 (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
8050 (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
8051 gc->pc += cmdlen;
8052 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8053 (void) __glXFlushRenderBuffer(gc, gc->pc);
8054 }
8055 }
8056
8057 #define X_GLrop_VertexAttrib4NubvARB 4201
8058 void
8059 __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte *v)
8060 {
8061 __GLXcontext *const gc = __glXGetCurrentContext();
8062 const GLuint cmdlen = 12;
8063 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
8064 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8065 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8066 gc->pc += cmdlen;
8067 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8068 (void) __glXFlushRenderBuffer(gc, gc->pc);
8069 }
8070 }
8071
8072 #define X_GLrop_VertexAttrib4NuivARB 4239
8073 void
8074 __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
8075 {
8076 __GLXcontext *const gc = __glXGetCurrentContext();
8077 const GLuint cmdlen = 24;
8078 emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
8079 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8080 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8081 gc->pc += cmdlen;
8082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8083 (void) __glXFlushRenderBuffer(gc, gc->pc);
8084 }
8085 }
8086
8087 #define X_GLrop_VertexAttrib4NusvARB 4238
8088 void
8089 __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
8090 {
8091 __GLXcontext *const gc = __glXGetCurrentContext();
8092 const GLuint cmdlen = 16;
8093 emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
8094 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8095 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8096 gc->pc += cmdlen;
8097 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8098 (void) __glXFlushRenderBuffer(gc, gc->pc);
8099 }
8100 }
8101
8102 #define X_GLrop_VertexAttrib4bvARB 4230
8103 void
8104 __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte *v)
8105 {
8106 __GLXcontext *const gc = __glXGetCurrentContext();
8107 const GLuint cmdlen = 12;
8108 emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
8109 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8110 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8111 gc->pc += cmdlen;
8112 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8113 (void) __glXFlushRenderBuffer(gc, gc->pc);
8114 }
8115 }
8116
8117 #define X_GLrop_VertexAttrib4dvARB 4200
8118 void
8119 __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y,
8120 GLdouble z, GLdouble w)
8121 {
8122 __GLXcontext *const gc = __glXGetCurrentContext();
8123 const GLuint cmdlen = 40;
8124 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
8125 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8126 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
8127 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
8128 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
8129 (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
8130 gc->pc += cmdlen;
8131 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8132 (void) __glXFlushRenderBuffer(gc, gc->pc);
8133 }
8134 }
8135
8136 #define X_GLrop_VertexAttrib4dvARB 4200
8137 void
8138 __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
8139 {
8140 __GLXcontext *const gc = __glXGetCurrentContext();
8141 const GLuint cmdlen = 40;
8142 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
8143 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8144 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
8145 gc->pc += cmdlen;
8146 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8147 (void) __glXFlushRenderBuffer(gc, gc->pc);
8148 }
8149 }
8150
8151 #define X_GLrop_VertexAttrib4fvARB 4196
8152 void
8153 __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
8154 GLfloat w)
8155 {
8156 __GLXcontext *const gc = __glXGetCurrentContext();
8157 const GLuint cmdlen = 24;
8158 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
8159 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8160 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
8161 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
8162 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
8163 (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
8164 gc->pc += cmdlen;
8165 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8166 (void) __glXFlushRenderBuffer(gc, gc->pc);
8167 }
8168 }
8169
8170 #define X_GLrop_VertexAttrib4fvARB 4196
8171 void
8172 __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
8173 {
8174 __GLXcontext *const gc = __glXGetCurrentContext();
8175 const GLuint cmdlen = 24;
8176 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
8177 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8178 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8179 gc->pc += cmdlen;
8180 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8181 (void) __glXFlushRenderBuffer(gc, gc->pc);
8182 }
8183 }
8184
8185 #define X_GLrop_VertexAttrib4ivARB 4231
8186 void
8187 __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
8188 {
8189 __GLXcontext *const gc = __glXGetCurrentContext();
8190 const GLuint cmdlen = 24;
8191 emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
8192 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8193 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8194 gc->pc += cmdlen;
8195 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8196 (void) __glXFlushRenderBuffer(gc, gc->pc);
8197 }
8198 }
8199
8200 #define X_GLrop_VertexAttrib4svARB 4192
8201 void
8202 __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z,
8203 GLshort w)
8204 {
8205 __GLXcontext *const gc = __glXGetCurrentContext();
8206 const GLuint cmdlen = 16;
8207 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
8208 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8209 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
8210 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
8211 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
8212 (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
8213 gc->pc += cmdlen;
8214 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8215 (void) __glXFlushRenderBuffer(gc, gc->pc);
8216 }
8217 }
8218
8219 #define X_GLrop_VertexAttrib4svARB 4192
8220 void
8221 __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
8222 {
8223 __GLXcontext *const gc = __glXGetCurrentContext();
8224 const GLuint cmdlen = 16;
8225 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
8226 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8227 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8228 gc->pc += cmdlen;
8229 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8230 (void) __glXFlushRenderBuffer(gc, gc->pc);
8231 }
8232 }
8233
8234 #define X_GLrop_VertexAttrib4ubvARB 4232
8235 void
8236 __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte *v)
8237 {
8238 __GLXcontext *const gc = __glXGetCurrentContext();
8239 const GLuint cmdlen = 12;
8240 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
8241 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8242 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8243 gc->pc += cmdlen;
8244 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8245 (void) __glXFlushRenderBuffer(gc, gc->pc);
8246 }
8247 }
8248
8249 #define X_GLrop_VertexAttrib4uivARB 4234
8250 void
8251 __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
8252 {
8253 __GLXcontext *const gc = __glXGetCurrentContext();
8254 const GLuint cmdlen = 24;
8255 emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
8256 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8257 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8258 gc->pc += cmdlen;
8259 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8260 (void) __glXFlushRenderBuffer(gc, gc->pc);
8261 }
8262 }
8263
8264 #define X_GLrop_VertexAttrib4usvARB 4233
8265 void
8266 __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
8267 {
8268 __GLXcontext *const gc = __glXGetCurrentContext();
8269 const GLuint cmdlen = 16;
8270 emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
8271 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8272 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8273 gc->pc += cmdlen;
8274 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8275 (void) __glXFlushRenderBuffer(gc, gc->pc);
8276 }
8277 }
8278
8279 #define X_GLrop_BeginQueryARB 231
8280 void
8281 __indirect_glBeginQueryARB(GLenum target, GLuint id)
8282 {
8283 __GLXcontext *const gc = __glXGetCurrentContext();
8284 const GLuint cmdlen = 12;
8285 emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
8286 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8287 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
8288 gc->pc += cmdlen;
8289 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8290 (void) __glXFlushRenderBuffer(gc, gc->pc);
8291 }
8292 }
8293
8294 #define X_GLsop_DeleteQueriesARB 161
8295 void
8296 __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
8297 {
8298 __GLXcontext *const gc = __glXGetCurrentContext();
8299 Display *const dpy = gc->currentDpy;
8300 #ifndef USE_XCB
8301 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8302 #endif
8303 if (n < 0) {
8304 __glXSetError(gc, GL_INVALID_VALUE);
8305 return;
8306 }
8307 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8308 #ifdef USE_XCB
8309 xcb_connection_t *c = XGetXCBConnection(dpy);
8310 (void) __glXFlushRenderBuffer(gc, gc->pc);
8311 xcb_glx_delete_queries_arb(c, gc->currentContextTag, n, ids);
8312 #else
8313 GLubyte const *pc =
8314 __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
8315 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8316 (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
8317 UnlockDisplay(dpy);
8318 SyncHandle();
8319 #endif /* USE_XCB */
8320 }
8321 return;
8322 }
8323
8324 #define X_GLrop_EndQueryARB 232
8325 void
8326 __indirect_glEndQueryARB(GLenum target)
8327 {
8328 __GLXcontext *const gc = __glXGetCurrentContext();
8329 const GLuint cmdlen = 8;
8330 emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
8331 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8332 gc->pc += cmdlen;
8333 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8334 (void) __glXFlushRenderBuffer(gc, gc->pc);
8335 }
8336 }
8337
8338 #define X_GLsop_GenQueriesARB 162
8339 void
8340 __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
8341 {
8342 __GLXcontext *const gc = __glXGetCurrentContext();
8343 Display *const dpy = gc->currentDpy;
8344 #ifndef USE_XCB
8345 const GLuint cmdlen = 4;
8346 #endif
8347 if (n < 0) {
8348 __glXSetError(gc, GL_INVALID_VALUE);
8349 return;
8350 }
8351 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8352 #ifdef USE_XCB
8353 xcb_connection_t *c = XGetXCBConnection(dpy);
8354 (void) __glXFlushRenderBuffer(gc, gc->pc);
8355 xcb_glx_gen_queries_arb_reply_t *reply =
8356 xcb_glx_gen_queries_arb_reply(c,
8357 xcb_glx_gen_queries_arb(c,
8358 gc->
8359 currentContextTag,
8360 n), NULL);
8361 (void) memcpy(ids, xcb_glx_gen_queries_arb_data(reply),
8362 xcb_glx_gen_queries_arb_data_length(reply) *
8363 sizeof(GLuint));
8364 free(reply);
8365 #else
8366 GLubyte const *pc =
8367 __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
8368 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8369 (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
8370 UnlockDisplay(dpy);
8371 SyncHandle();
8372 #endif /* USE_XCB */
8373 }
8374 return;
8375 }
8376
8377 #define X_GLsop_GetQueryObjectivARB 165
8378 void
8379 __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
8380 {
8381 __GLXcontext *const gc = __glXGetCurrentContext();
8382 Display *const dpy = gc->currentDpy;
8383 #ifndef USE_XCB
8384 const GLuint cmdlen = 8;
8385 #endif
8386 if (__builtin_expect(dpy != NULL, 1)) {
8387 #ifdef USE_XCB
8388 xcb_connection_t *c = XGetXCBConnection(dpy);
8389 (void) __glXFlushRenderBuffer(gc, gc->pc);
8390 xcb_glx_get_query_objectiv_arb_reply_t *reply =
8391 xcb_glx_get_query_objectiv_arb_reply(c,
8392 xcb_glx_get_query_objectiv_arb
8393 (c, gc->currentContextTag,
8394 id, pname), NULL);
8395 if (xcb_glx_get_query_objectiv_arb_data_length(reply) == 0)
8396 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8397 else
8398 (void) memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply),
8399 xcb_glx_get_query_objectiv_arb_data_length(reply) *
8400 sizeof(GLint));
8401 free(reply);
8402 #else
8403 GLubyte const *pc =
8404 __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
8405 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8406 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8407 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8408 UnlockDisplay(dpy);
8409 SyncHandle();
8410 #endif /* USE_XCB */
8411 }
8412 return;
8413 }
8414
8415 #define X_GLsop_GetQueryObjectuivARB 166
8416 void
8417 __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
8418 {
8419 __GLXcontext *const gc = __glXGetCurrentContext();
8420 Display *const dpy = gc->currentDpy;
8421 #ifndef USE_XCB
8422 const GLuint cmdlen = 8;
8423 #endif
8424 if (__builtin_expect(dpy != NULL, 1)) {
8425 #ifdef USE_XCB
8426 xcb_connection_t *c = XGetXCBConnection(dpy);
8427 (void) __glXFlushRenderBuffer(gc, gc->pc);
8428 xcb_glx_get_query_objectuiv_arb_reply_t *reply =
8429 xcb_glx_get_query_objectuiv_arb_reply(c,
8430 xcb_glx_get_query_objectuiv_arb
8431 (c, gc->currentContextTag,
8432 id, pname), NULL);
8433 if (xcb_glx_get_query_objectuiv_arb_data_length(reply) == 0)
8434 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8435 else
8436 (void) memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply),
8437 xcb_glx_get_query_objectuiv_arb_data_length(reply) *
8438 sizeof(GLuint));
8439 free(reply);
8440 #else
8441 GLubyte const *pc =
8442 __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
8443 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8444 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8445 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8446 UnlockDisplay(dpy);
8447 SyncHandle();
8448 #endif /* USE_XCB */
8449 }
8450 return;
8451 }
8452
8453 #define X_GLsop_GetQueryivARB 164
8454 void
8455 __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
8456 {
8457 __GLXcontext *const gc = __glXGetCurrentContext();
8458 Display *const dpy = gc->currentDpy;
8459 #ifndef USE_XCB
8460 const GLuint cmdlen = 8;
8461 #endif
8462 if (__builtin_expect(dpy != NULL, 1)) {
8463 #ifdef USE_XCB
8464 xcb_connection_t *c = XGetXCBConnection(dpy);
8465 (void) __glXFlushRenderBuffer(gc, gc->pc);
8466 xcb_glx_get_queryiv_arb_reply_t *reply =
8467 xcb_glx_get_queryiv_arb_reply(c,
8468 xcb_glx_get_queryiv_arb(c,
8469 gc->
8470 currentContextTag,
8471 target,
8472 pname),
8473 NULL);
8474 if (xcb_glx_get_queryiv_arb_data_length(reply) == 0)
8475 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8476 else
8477 (void) memcpy(params, xcb_glx_get_queryiv_arb_data(reply),
8478 xcb_glx_get_queryiv_arb_data_length(reply) *
8479 sizeof(GLint));
8480 free(reply);
8481 #else
8482 GLubyte const *pc =
8483 __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
8484 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
8485 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8486 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8487 UnlockDisplay(dpy);
8488 SyncHandle();
8489 #endif /* USE_XCB */
8490 }
8491 return;
8492 }
8493
8494 #define X_GLsop_IsQueryARB 163
8495 GLboolean
8496 __indirect_glIsQueryARB(GLuint id)
8497 {
8498 __GLXcontext *const gc = __glXGetCurrentContext();
8499 Display *const dpy = gc->currentDpy;
8500 GLboolean retval = (GLboolean) 0;
8501 #ifndef USE_XCB
8502 const GLuint cmdlen = 4;
8503 #endif
8504 if (__builtin_expect(dpy != NULL, 1)) {
8505 #ifdef USE_XCB
8506 xcb_connection_t *c = XGetXCBConnection(dpy);
8507 (void) __glXFlushRenderBuffer(gc, gc->pc);
8508 xcb_glx_is_query_arb_reply_t *reply =
8509 xcb_glx_is_query_arb_reply(c,
8510 xcb_glx_is_query_arb(c,
8511 gc->
8512 currentContextTag,
8513 id), NULL);
8514 retval = reply->ret_val;
8515 free(reply);
8516 #else
8517 GLubyte const *pc =
8518 __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
8519 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8520 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
8521 UnlockDisplay(dpy);
8522 SyncHandle();
8523 #endif /* USE_XCB */
8524 }
8525 return retval;
8526 }
8527
8528 #define X_GLrop_DrawBuffersARB 233
8529 void
8530 __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
8531 {
8532 __GLXcontext *const gc = __glXGetCurrentContext();
8533 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
8534 if (n < 0) {
8535 __glXSetError(gc, GL_INVALID_VALUE);
8536 return;
8537 }
8538 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
8539 if (cmdlen <= gc->maxSmallRenderCommandSize) {
8540 if ((gc->pc + cmdlen) > gc->bufEnd) {
8541 (void) __glXFlushRenderBuffer(gc, gc->pc);
8542 }
8543 emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
8544 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
8545 (void) memcpy((void *) (gc->pc + 8), (void *) (bufs), (n * 4));
8546 gc->pc += cmdlen;
8547 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8548 (void) __glXFlushRenderBuffer(gc, gc->pc);
8549 }
8550 } else {
8551 const GLint op = X_GLrop_DrawBuffersARB;
8552 const GLuint cmdlenLarge = cmdlen + 4;
8553 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
8554 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
8555 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
8556 (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
8557 __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
8558 }
8559 }
8560 }
8561
8562 #define X_GLrop_SampleMaskSGIS 2048
8563 void
8564 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
8565 {
8566 __GLXcontext *const gc = __glXGetCurrentContext();
8567 const GLuint cmdlen = 12;
8568 emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
8569 (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
8570 (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
8571 gc->pc += cmdlen;
8572 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8573 (void) __glXFlushRenderBuffer(gc, gc->pc);
8574 }
8575 }
8576
8577 #define X_GLrop_SamplePatternSGIS 2049
8578 void
8579 __indirect_glSamplePatternSGIS(GLenum pattern)
8580 {
8581 __GLXcontext *const gc = __glXGetCurrentContext();
8582 const GLuint cmdlen = 8;
8583 emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
8584 (void) memcpy((void *) (gc->pc + 4), (void *) (&pattern), 4);
8585 gc->pc += cmdlen;
8586 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8587 (void) __glXFlushRenderBuffer(gc, gc->pc);
8588 }
8589 }
8590
8591 #define X_GLrop_PointParameterfEXT 2065
8592 void
8593 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
8594 {
8595 __GLXcontext *const gc = __glXGetCurrentContext();
8596 const GLuint cmdlen = 12;
8597 emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
8598 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
8599 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
8600 gc->pc += cmdlen;
8601 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8602 (void) __glXFlushRenderBuffer(gc, gc->pc);
8603 }
8604 }
8605
8606 #define X_GLrop_PointParameterfvEXT 2066
8607 void
8608 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
8609 {
8610 __GLXcontext *const gc = __glXGetCurrentContext();
8611 const GLuint compsize = __glPointParameterfvEXT_size(pname);
8612 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
8613 emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
8614 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
8615 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
8616 gc->pc += cmdlen;
8617 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8618 (void) __glXFlushRenderBuffer(gc, gc->pc);
8619 }
8620 }
8621
8622 #define X_GLrop_SecondaryColor3bvEXT 4126
8623 void
8624 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
8625 {
8626 __GLXcontext *const gc = __glXGetCurrentContext();
8627 const GLuint cmdlen = 8;
8628 emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
8629 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
8630 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
8631 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
8632 gc->pc += cmdlen;
8633 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8634 (void) __glXFlushRenderBuffer(gc, gc->pc);
8635 }
8636 }
8637
8638 #define X_GLrop_SecondaryColor3bvEXT 4126
8639 void
8640 __indirect_glSecondaryColor3bvEXT(const GLbyte *v)
8641 {
8642 generic_3_byte(X_GLrop_SecondaryColor3bvEXT, v);
8643 }
8644
8645 #define X_GLrop_SecondaryColor3dvEXT 4130
8646 void
8647 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
8648 {
8649 __GLXcontext *const gc = __glXGetCurrentContext();
8650 const GLuint cmdlen = 28;
8651 emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
8652 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
8653 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
8654 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
8655 gc->pc += cmdlen;
8656 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8657 (void) __glXFlushRenderBuffer(gc, gc->pc);
8658 }
8659 }
8660
8661 #define X_GLrop_SecondaryColor3dvEXT 4130
8662 void
8663 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
8664 {
8665 generic_24_byte(X_GLrop_SecondaryColor3dvEXT, v);
8666 }
8667
8668 #define X_GLrop_SecondaryColor3fvEXT 4129
8669 void
8670 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
8671 {
8672 __GLXcontext *const gc = __glXGetCurrentContext();
8673 const GLuint cmdlen = 16;
8674 emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
8675 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8676 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8677 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8678 gc->pc += cmdlen;
8679 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8680 (void) __glXFlushRenderBuffer(gc, gc->pc);
8681 }
8682 }
8683
8684 #define X_GLrop_SecondaryColor3fvEXT 4129
8685 void
8686 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
8687 {
8688 generic_12_byte(X_GLrop_SecondaryColor3fvEXT, v);
8689 }
8690
8691 #define X_GLrop_SecondaryColor3ivEXT 4128
8692 void
8693 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
8694 {
8695 __GLXcontext *const gc = __glXGetCurrentContext();
8696 const GLuint cmdlen = 16;
8697 emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
8698 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8699 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8700 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8701 gc->pc += cmdlen;
8702 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8703 (void) __glXFlushRenderBuffer(gc, gc->pc);
8704 }
8705 }
8706
8707 #define X_GLrop_SecondaryColor3ivEXT 4128
8708 void
8709 __indirect_glSecondaryColor3ivEXT(const GLint * v)
8710 {
8711 generic_12_byte(X_GLrop_SecondaryColor3ivEXT, v);
8712 }
8713
8714 #define X_GLrop_SecondaryColor3svEXT 4127
8715 void
8716 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
8717 {
8718 __GLXcontext *const gc = __glXGetCurrentContext();
8719 const GLuint cmdlen = 12;
8720 emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
8721 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
8722 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
8723 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
8724 gc->pc += cmdlen;
8725 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8726 (void) __glXFlushRenderBuffer(gc, gc->pc);
8727 }
8728 }
8729
8730 #define X_GLrop_SecondaryColor3svEXT 4127
8731 void
8732 __indirect_glSecondaryColor3svEXT(const GLshort * v)
8733 {
8734 generic_6_byte(X_GLrop_SecondaryColor3svEXT, v);
8735 }
8736
8737 #define X_GLrop_SecondaryColor3ubvEXT 4131
8738 void
8739 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
8740 {
8741 __GLXcontext *const gc = __glXGetCurrentContext();
8742 const GLuint cmdlen = 8;
8743 emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
8744 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
8745 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
8746 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
8747 gc->pc += cmdlen;
8748 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8749 (void) __glXFlushRenderBuffer(gc, gc->pc);
8750 }
8751 }
8752
8753 #define X_GLrop_SecondaryColor3ubvEXT 4131
8754 void
8755 __indirect_glSecondaryColor3ubvEXT(const GLubyte *v)
8756 {
8757 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT, v);
8758 }
8759
8760 #define X_GLrop_SecondaryColor3uivEXT 4133
8761 void
8762 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
8763 {
8764 __GLXcontext *const gc = __glXGetCurrentContext();
8765 const GLuint cmdlen = 16;
8766 emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
8767 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8768 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8769 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8770 gc->pc += cmdlen;
8771 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8772 (void) __glXFlushRenderBuffer(gc, gc->pc);
8773 }
8774 }
8775
8776 #define X_GLrop_SecondaryColor3uivEXT 4133
8777 void
8778 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
8779 {
8780 generic_12_byte(X_GLrop_SecondaryColor3uivEXT, v);
8781 }
8782
8783 #define X_GLrop_SecondaryColor3usvEXT 4132
8784 void
8785 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
8786 {
8787 __GLXcontext *const gc = __glXGetCurrentContext();
8788 const GLuint cmdlen = 12;
8789 emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
8790 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
8791 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
8792 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
8793 gc->pc += cmdlen;
8794 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8795 (void) __glXFlushRenderBuffer(gc, gc->pc);
8796 }
8797 }
8798
8799 #define X_GLrop_SecondaryColor3usvEXT 4132
8800 void
8801 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
8802 {
8803 generic_6_byte(X_GLrop_SecondaryColor3usvEXT, v);
8804 }
8805
8806 #define X_GLrop_FogCoorddvEXT 4125
8807 void
8808 __indirect_glFogCoorddEXT(GLdouble coord)
8809 {
8810 __GLXcontext *const gc = __glXGetCurrentContext();
8811 const GLuint cmdlen = 12;
8812 emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
8813 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 8);
8814 gc->pc += cmdlen;
8815 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8816 (void) __glXFlushRenderBuffer(gc, gc->pc);
8817 }
8818 }
8819
8820 #define X_GLrop_FogCoorddvEXT 4125
8821 void
8822 __indirect_glFogCoorddvEXT(const GLdouble * coord)
8823 {
8824 generic_8_byte(X_GLrop_FogCoorddvEXT, coord);
8825 }
8826
8827 #define X_GLrop_FogCoordfvEXT 4124
8828 void
8829 __indirect_glFogCoordfEXT(GLfloat coord)
8830 {
8831 __GLXcontext *const gc = __glXGetCurrentContext();
8832 const GLuint cmdlen = 8;
8833 emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
8834 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
8835 gc->pc += cmdlen;
8836 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8837 (void) __glXFlushRenderBuffer(gc, gc->pc);
8838 }
8839 }
8840
8841 #define X_GLrop_FogCoordfvEXT 4124
8842 void
8843 __indirect_glFogCoordfvEXT(const GLfloat * coord)
8844 {
8845 generic_4_byte(X_GLrop_FogCoordfvEXT, coord);
8846 }
8847
8848 #define X_GLrop_BlendFuncSeparateEXT 4134
8849 void
8850 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
8851 GLenum sfactorAlpha, GLenum dfactorAlpha)
8852 {
8853 __GLXcontext *const gc = __glXGetCurrentContext();
8854 const GLuint cmdlen = 20;
8855 emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
8856 (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactorRGB), 4);
8857 (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactorRGB), 4);
8858 (void) memcpy((void *) (gc->pc + 12), (void *) (&sfactorAlpha), 4);
8859 (void) memcpy((void *) (gc->pc + 16), (void *) (&dfactorAlpha), 4);
8860 gc->pc += cmdlen;
8861 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8862 (void) __glXFlushRenderBuffer(gc, gc->pc);
8863 }
8864 }
8865
8866 #define X_GLrop_WindowPos3fvMESA 230
8867 void
8868 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
8869 {
8870 __GLXcontext *const gc = __glXGetCurrentContext();
8871 const GLuint cmdlen = 16;
8872 emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
8873 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
8874 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
8875 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
8876 gc->pc += cmdlen;
8877 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8878 (void) __glXFlushRenderBuffer(gc, gc->pc);
8879 }
8880 }
8881
8882 #define X_GLrop_WindowPos3fvMESA 230
8883 void
8884 __indirect_glWindowPos3fvMESA(const GLfloat * v)
8885 {
8886 generic_12_byte(X_GLrop_WindowPos3fvMESA, v);
8887 }
8888
8889 #define X_GLvop_AreProgramsResidentNV 1293
8890 GLboolean
8891 __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids,
8892 GLboolean * residences)
8893 {
8894 __GLXcontext *const gc = __glXGetCurrentContext();
8895 Display *const dpy = gc->currentDpy;
8896 GLboolean retval = (GLboolean) 0;
8897 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8898 if (n < 0) {
8899 __glXSetError(gc, GL_INVALID_VALUE);
8900 return 0;
8901 }
8902 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8903 GLubyte const *pc =
8904 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8905 X_GLvop_AreProgramsResidentNV, cmdlen);
8906 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8907 (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
8908 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
8909 UnlockDisplay(dpy);
8910 SyncHandle();
8911 }
8912 return retval;
8913 }
8914
8915 #define X_GLrop_BindProgramNV 4180
8916 void
8917 __indirect_glBindProgramNV(GLenum target, GLuint program)
8918 {
8919 __GLXcontext *const gc = __glXGetCurrentContext();
8920 const GLuint cmdlen = 12;
8921 emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
8922 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8923 (void) memcpy((void *) (gc->pc + 8), (void *) (&program), 4);
8924 gc->pc += cmdlen;
8925 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8926 (void) __glXFlushRenderBuffer(gc, gc->pc);
8927 }
8928 }
8929
8930 #define X_GLvop_DeleteProgramsNV 1294
8931 void
8932 __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
8933 {
8934 __GLXcontext *const gc = __glXGetCurrentContext();
8935 Display *const dpy = gc->currentDpy;
8936 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8937 if (n < 0) {
8938 __glXSetError(gc, GL_INVALID_VALUE);
8939 return;
8940 }
8941 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8942 GLubyte const *pc =
8943 __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
8944 X_GLvop_DeleteProgramsNV, cmdlen);
8945 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8946 (void) memcpy((void *) (pc + 4), (void *) (programs), (n * 4));
8947 UnlockDisplay(dpy);
8948 SyncHandle();
8949 }
8950 return;
8951 }
8952
8953 #define X_GLrop_ExecuteProgramNV 4181
8954 void
8955 __indirect_glExecuteProgramNV(GLenum target, GLuint id,
8956 const GLfloat * params)
8957 {
8958 __GLXcontext *const gc = __glXGetCurrentContext();
8959 const GLuint cmdlen = 28;
8960 emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
8961 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8962 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
8963 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
8964 gc->pc += cmdlen;
8965 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8966 (void) __glXFlushRenderBuffer(gc, gc->pc);
8967 }
8968 }
8969
8970 #define X_GLvop_GenProgramsNV 1295
8971 void
8972 __indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
8973 {
8974 __GLXcontext *const gc = __glXGetCurrentContext();
8975 Display *const dpy = gc->currentDpy;
8976 const GLuint cmdlen = 4;
8977 if (n < 0) {
8978 __glXSetError(gc, GL_INVALID_VALUE);
8979 return;
8980 }
8981 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8982 GLubyte const *pc =
8983 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8984 X_GLvop_GenProgramsNV, cmdlen);
8985 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8986 (void) __glXReadReply(dpy, 4, programs, GL_TRUE);
8987 UnlockDisplay(dpy);
8988 SyncHandle();
8989 }
8990 return;
8991 }
8992
8993 #define X_GLvop_GetProgramParameterdvNV 1297
8994 void
8995 __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index,
8996 GLenum pname, GLdouble * params)
8997 {
8998 __GLXcontext *const gc = __glXGetCurrentContext();
8999 Display *const dpy = gc->currentDpy;
9000 const GLuint cmdlen = 12;
9001 if (__builtin_expect(dpy != NULL, 1)) {
9002 GLubyte const *pc =
9003 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9004 X_GLvop_GetProgramParameterdvNV, cmdlen);
9005 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9006 (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
9007 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9008 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
9009 UnlockDisplay(dpy);
9010 SyncHandle();
9011 }
9012 return;
9013 }
9014
9015 #define X_GLvop_GetProgramParameterfvNV 1296
9016 void
9017 __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index,
9018 GLenum pname, GLfloat * params)
9019 {
9020 __GLXcontext *const gc = __glXGetCurrentContext();
9021 Display *const dpy = gc->currentDpy;
9022 const GLuint cmdlen = 12;
9023 if (__builtin_expect(dpy != NULL, 1)) {
9024 GLubyte const *pc =
9025 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9026 X_GLvop_GetProgramParameterfvNV, cmdlen);
9027 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9028 (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
9029 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9030 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9031 UnlockDisplay(dpy);
9032 SyncHandle();
9033 }
9034 return;
9035 }
9036
9037 #define X_GLvop_GetProgramStringNV 1299
9038 void
9039 __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
9040 {
9041 __GLXcontext *const gc = __glXGetCurrentContext();
9042 Display *const dpy = gc->currentDpy;
9043 const GLuint cmdlen = 8;
9044 if (__builtin_expect(dpy != NULL, 1)) {
9045 GLubyte const *pc =
9046 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9047 X_GLvop_GetProgramStringNV, cmdlen);
9048 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
9049 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9050 (void) __glXReadReply(dpy, 1, program, GL_TRUE);
9051 UnlockDisplay(dpy);
9052 SyncHandle();
9053 }
9054 return;
9055 }
9056
9057 #define X_GLvop_GetProgramivNV 1298
9058 void
9059 __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
9060 {
9061 __GLXcontext *const gc = __glXGetCurrentContext();
9062 Display *const dpy = gc->currentDpy;
9063 const GLuint cmdlen = 8;
9064 if (__builtin_expect(dpy != NULL, 1)) {
9065 GLubyte const *pc =
9066 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9067 X_GLvop_GetProgramivNV, cmdlen);
9068 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
9069 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9070 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9071 UnlockDisplay(dpy);
9072 SyncHandle();
9073 }
9074 return;
9075 }
9076
9077 #define X_GLvop_GetTrackMatrixivNV 1300
9078 void
9079 __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname,
9080 GLint * params)
9081 {
9082 __GLXcontext *const gc = __glXGetCurrentContext();
9083 Display *const dpy = gc->currentDpy;
9084 const GLuint cmdlen = 12;
9085 if (__builtin_expect(dpy != NULL, 1)) {
9086 GLubyte const *pc =
9087 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9088 X_GLvop_GetTrackMatrixivNV, cmdlen);
9089 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9090 (void) memcpy((void *) (pc + 4), (void *) (&address), 4);
9091 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9092 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9093 UnlockDisplay(dpy);
9094 SyncHandle();
9095 }
9096 return;
9097 }
9098
9099 #define X_GLvop_GetVertexAttribdvNV 1301
9100 void
9101 __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname,
9102 GLdouble * params)
9103 {
9104 __GLXcontext *const gc = __glXGetCurrentContext();
9105 Display *const dpy = gc->currentDpy;
9106 const GLuint cmdlen = 8;
9107 if (__builtin_expect(dpy != NULL, 1)) {
9108 GLubyte const *pc =
9109 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9110 X_GLvop_GetVertexAttribdvNV, cmdlen);
9111 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9112 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9113 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
9114 UnlockDisplay(dpy);
9115 SyncHandle();
9116 }
9117 return;
9118 }
9119
9120 #define X_GLvop_GetVertexAttribfvNV 1302
9121 void
9122 __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
9123 {
9124 __GLXcontext *const gc = __glXGetCurrentContext();
9125 Display *const dpy = gc->currentDpy;
9126 const GLuint cmdlen = 8;
9127 if (__builtin_expect(dpy != NULL, 1)) {
9128 GLubyte const *pc =
9129 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9130 X_GLvop_GetVertexAttribfvNV, cmdlen);
9131 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9132 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9133 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9134 UnlockDisplay(dpy);
9135 SyncHandle();
9136 }
9137 return;
9138 }
9139
9140 #define X_GLvop_GetVertexAttribivNV 1303
9141 void
9142 __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
9143 {
9144 __GLXcontext *const gc = __glXGetCurrentContext();
9145 Display *const dpy = gc->currentDpy;
9146 const GLuint cmdlen = 8;
9147 if (__builtin_expect(dpy != NULL, 1)) {
9148 GLubyte const *pc =
9149 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9150 X_GLvop_GetVertexAttribivNV, cmdlen);
9151 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9152 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9153 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9154 UnlockDisplay(dpy);
9155 SyncHandle();
9156 }
9157 return;
9158 }
9159
9160 #define X_GLvop_IsProgramNV 1304
9161 GLboolean
9162 __indirect_glIsProgramNV(GLuint program)
9163 {
9164 __GLXcontext *const gc = __glXGetCurrentContext();
9165 Display *const dpy = gc->currentDpy;
9166 GLboolean retval = (GLboolean) 0;
9167 const GLuint cmdlen = 4;
9168 if (__builtin_expect(dpy != NULL, 1)) {
9169 GLubyte const *pc =
9170 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9171 X_GLvop_IsProgramNV, cmdlen);
9172 (void) memcpy((void *) (pc + 0), (void *) (&program), 4);
9173 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
9174 UnlockDisplay(dpy);
9175 SyncHandle();
9176 }
9177 return retval;
9178 }
9179
9180 #define X_GLrop_LoadProgramNV 4183
9181 void
9182 __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len,
9183 const GLubyte *program)
9184 {
9185 __GLXcontext *const gc = __glXGetCurrentContext();
9186 const GLuint cmdlen = 16 + __GLX_PAD(len);
9187 if (len < 0) {
9188 __glXSetError(gc, GL_INVALID_VALUE);
9189 return;
9190 }
9191 if (__builtin_expect(len >= 0, 1)) {
9192 emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
9193 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9194 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
9195 (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
9196 (void) memcpy((void *) (gc->pc + 16), (void *) (program), len);
9197 gc->pc += cmdlen;
9198 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9199 (void) __glXFlushRenderBuffer(gc, gc->pc);
9200 }
9201 }
9202 }
9203
9204 #define X_GLrop_ProgramParameters4dvNV 4187
9205 void
9206 __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num,
9207 const GLdouble * params)
9208 {
9209 __GLXcontext *const gc = __glXGetCurrentContext();
9210 const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
9211 if (num < 0) {
9212 __glXSetError(gc, GL_INVALID_VALUE);
9213 return;
9214 }
9215 if (__builtin_expect(num >= 0, 1)) {
9216 emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
9217 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9218 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
9219 (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
9220 (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 32));
9221 gc->pc += cmdlen;
9222 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9223 (void) __glXFlushRenderBuffer(gc, gc->pc);
9224 }
9225 }
9226 }
9227
9228 #define X_GLrop_ProgramParameters4fvNV 4186
9229 void
9230 __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num,
9231 const GLfloat * params)
9232 {
9233 __GLXcontext *const gc = __glXGetCurrentContext();
9234 const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
9235 if (num < 0) {
9236 __glXSetError(gc, GL_INVALID_VALUE);
9237 return;
9238 }
9239 if (__builtin_expect(num >= 0, 1)) {
9240 emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
9241 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9242 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
9243 (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
9244 (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 16));
9245 gc->pc += cmdlen;
9246 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9247 (void) __glXFlushRenderBuffer(gc, gc->pc);
9248 }
9249 }
9250 }
9251
9252 #define X_GLrop_RequestResidentProgramsNV 4182
9253 void
9254 __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
9255 {
9256 __GLXcontext *const gc = __glXGetCurrentContext();
9257 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
9258 if (n < 0) {
9259 __glXSetError(gc, GL_INVALID_VALUE);
9260 return;
9261 }
9262 if (__builtin_expect(n >= 0, 1)) {
9263 emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
9264 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
9265 (void) memcpy((void *) (gc->pc + 8), (void *) (ids), (n * 4));
9266 gc->pc += cmdlen;
9267 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9268 (void) __glXFlushRenderBuffer(gc, gc->pc);
9269 }
9270 }
9271 }
9272
9273 #define X_GLrop_TrackMatrixNV 4188
9274 void
9275 __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix,
9276 GLenum transform)
9277 {
9278 __GLXcontext *const gc = __glXGetCurrentContext();
9279 const GLuint cmdlen = 20;
9280 emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
9281 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9282 (void) memcpy((void *) (gc->pc + 8), (void *) (&address), 4);
9283 (void) memcpy((void *) (gc->pc + 12), (void *) (&matrix), 4);
9284 (void) memcpy((void *) (gc->pc + 16), (void *) (&transform), 4);
9285 gc->pc += cmdlen;
9286 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9287 (void) __glXFlushRenderBuffer(gc, gc->pc);
9288 }
9289 }
9290
9291 #define X_GLrop_VertexAttrib1dvNV 4273
9292 void
9293 __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
9294 {
9295 __GLXcontext *const gc = __glXGetCurrentContext();
9296 const GLuint cmdlen = 16;
9297 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
9298 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9299 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9300 gc->pc += cmdlen;
9301 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9302 (void) __glXFlushRenderBuffer(gc, gc->pc);
9303 }
9304 }
9305
9306 #define X_GLrop_VertexAttrib1dvNV 4273
9307 void
9308 __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
9309 {
9310 __GLXcontext *const gc = __glXGetCurrentContext();
9311 const GLuint cmdlen = 16;
9312 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
9313 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9314 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9315 gc->pc += cmdlen;
9316 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9317 (void) __glXFlushRenderBuffer(gc, gc->pc);
9318 }
9319 }
9320
9321 #define X_GLrop_VertexAttrib1fvNV 4269
9322 void
9323 __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
9324 {
9325 __GLXcontext *const gc = __glXGetCurrentContext();
9326 const GLuint cmdlen = 12;
9327 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
9328 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9329 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9330 gc->pc += cmdlen;
9331 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9332 (void) __glXFlushRenderBuffer(gc, gc->pc);
9333 }
9334 }
9335
9336 #define X_GLrop_VertexAttrib1fvNV 4269
9337 void
9338 __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
9339 {
9340 __GLXcontext *const gc = __glXGetCurrentContext();
9341 const GLuint cmdlen = 12;
9342 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
9343 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9344 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9345 gc->pc += cmdlen;
9346 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9347 (void) __glXFlushRenderBuffer(gc, gc->pc);
9348 }
9349 }
9350
9351 #define X_GLrop_VertexAttrib1svNV 4265
9352 void
9353 __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
9354 {
9355 __GLXcontext *const gc = __glXGetCurrentContext();
9356 const GLuint cmdlen = 12;
9357 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
9358 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9359 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9360 gc->pc += cmdlen;
9361 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9362 (void) __glXFlushRenderBuffer(gc, gc->pc);
9363 }
9364 }
9365
9366 #define X_GLrop_VertexAttrib1svNV 4265
9367 void
9368 __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
9369 {
9370 __GLXcontext *const gc = __glXGetCurrentContext();
9371 const GLuint cmdlen = 12;
9372 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
9373 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9374 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
9375 gc->pc += cmdlen;
9376 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9377 (void) __glXFlushRenderBuffer(gc, gc->pc);
9378 }
9379 }
9380
9381 #define X_GLrop_VertexAttrib2dvNV 4274
9382 void
9383 __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
9384 {
9385 __GLXcontext *const gc = __glXGetCurrentContext();
9386 const GLuint cmdlen = 24;
9387 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
9388 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9389 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9390 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9391 gc->pc += cmdlen;
9392 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9393 (void) __glXFlushRenderBuffer(gc, gc->pc);
9394 }
9395 }
9396
9397 #define X_GLrop_VertexAttrib2dvNV 4274
9398 void
9399 __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
9400 {
9401 __GLXcontext *const gc = __glXGetCurrentContext();
9402 const GLuint cmdlen = 24;
9403 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
9404 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9405 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
9406 gc->pc += cmdlen;
9407 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9408 (void) __glXFlushRenderBuffer(gc, gc->pc);
9409 }
9410 }
9411
9412 #define X_GLrop_VertexAttrib2fvNV 4270
9413 void
9414 __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
9415 {
9416 __GLXcontext *const gc = __glXGetCurrentContext();
9417 const GLuint cmdlen = 16;
9418 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
9419 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9420 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9421 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9422 gc->pc += cmdlen;
9423 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9424 (void) __glXFlushRenderBuffer(gc, gc->pc);
9425 }
9426 }
9427
9428 #define X_GLrop_VertexAttrib2fvNV 4270
9429 void
9430 __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
9431 {
9432 __GLXcontext *const gc = __glXGetCurrentContext();
9433 const GLuint cmdlen = 16;
9434 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
9435 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9436 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9437 gc->pc += cmdlen;
9438 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9439 (void) __glXFlushRenderBuffer(gc, gc->pc);
9440 }
9441 }
9442
9443 #define X_GLrop_VertexAttrib2svNV 4266
9444 void
9445 __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
9446 {
9447 __GLXcontext *const gc = __glXGetCurrentContext();
9448 const GLuint cmdlen = 12;
9449 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
9450 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9451 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9452 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9453 gc->pc += cmdlen;
9454 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9455 (void) __glXFlushRenderBuffer(gc, gc->pc);
9456 }
9457 }
9458
9459 #define X_GLrop_VertexAttrib2svNV 4266
9460 void
9461 __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
9462 {
9463 __GLXcontext *const gc = __glXGetCurrentContext();
9464 const GLuint cmdlen = 12;
9465 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
9466 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9467 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9468 gc->pc += cmdlen;
9469 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9470 (void) __glXFlushRenderBuffer(gc, gc->pc);
9471 }
9472 }
9473
9474 #define X_GLrop_VertexAttrib3dvNV 4275
9475 void
9476 __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y,
9477 GLdouble z)
9478 {
9479 __GLXcontext *const gc = __glXGetCurrentContext();
9480 const GLuint cmdlen = 32;
9481 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
9482 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9483 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9484 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9485 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
9486 gc->pc += cmdlen;
9487 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9488 (void) __glXFlushRenderBuffer(gc, gc->pc);
9489 }
9490 }
9491
9492 #define X_GLrop_VertexAttrib3dvNV 4275
9493 void
9494 __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
9495 {
9496 __GLXcontext *const gc = __glXGetCurrentContext();
9497 const GLuint cmdlen = 32;
9498 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
9499 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9500 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
9501 gc->pc += cmdlen;
9502 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9503 (void) __glXFlushRenderBuffer(gc, gc->pc);
9504 }
9505 }
9506
9507 #define X_GLrop_VertexAttrib3fvNV 4271
9508 void
9509 __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
9510 {
9511 __GLXcontext *const gc = __glXGetCurrentContext();
9512 const GLuint cmdlen = 20;
9513 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
9514 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9515 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9516 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9517 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
9518 gc->pc += cmdlen;
9519 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9520 (void) __glXFlushRenderBuffer(gc, gc->pc);
9521 }
9522 }
9523
9524 #define X_GLrop_VertexAttrib3fvNV 4271
9525 void
9526 __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
9527 {
9528 __GLXcontext *const gc = __glXGetCurrentContext();
9529 const GLuint cmdlen = 20;
9530 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
9531 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9532 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
9533 gc->pc += cmdlen;
9534 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9535 (void) __glXFlushRenderBuffer(gc, gc->pc);
9536 }
9537 }
9538
9539 #define X_GLrop_VertexAttrib3svNV 4267
9540 void
9541 __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
9542 {
9543 __GLXcontext *const gc = __glXGetCurrentContext();
9544 const GLuint cmdlen = 16;
9545 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
9546 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9547 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9548 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9549 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
9550 gc->pc += cmdlen;
9551 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9552 (void) __glXFlushRenderBuffer(gc, gc->pc);
9553 }
9554 }
9555
9556 #define X_GLrop_VertexAttrib3svNV 4267
9557 void
9558 __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
9559 {
9560 __GLXcontext *const gc = __glXGetCurrentContext();
9561 const GLuint cmdlen = 16;
9562 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
9563 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9564 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
9565 gc->pc += cmdlen;
9566 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9567 (void) __glXFlushRenderBuffer(gc, gc->pc);
9568 }
9569 }
9570
9571 #define X_GLrop_VertexAttrib4dvNV 4276
9572 void
9573 __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y,
9574 GLdouble z, GLdouble w)
9575 {
9576 __GLXcontext *const gc = __glXGetCurrentContext();
9577 const GLuint cmdlen = 40;
9578 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
9579 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9580 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9581 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9582 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
9583 (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
9584 gc->pc += cmdlen;
9585 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9586 (void) __glXFlushRenderBuffer(gc, gc->pc);
9587 }
9588 }
9589
9590 #define X_GLrop_VertexAttrib4dvNV 4276
9591 void
9592 __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
9593 {
9594 __GLXcontext *const gc = __glXGetCurrentContext();
9595 const GLuint cmdlen = 40;
9596 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
9597 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9598 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
9599 gc->pc += cmdlen;
9600 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9601 (void) __glXFlushRenderBuffer(gc, gc->pc);
9602 }
9603 }
9604
9605 #define X_GLrop_VertexAttrib4fvNV 4272
9606 void
9607 __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z,
9608 GLfloat w)
9609 {
9610 __GLXcontext *const gc = __glXGetCurrentContext();
9611 const GLuint cmdlen = 24;
9612 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
9613 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9614 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9615 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9616 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
9617 (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
9618 gc->pc += cmdlen;
9619 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9620 (void) __glXFlushRenderBuffer(gc, gc->pc);
9621 }
9622 }
9623
9624 #define X_GLrop_VertexAttrib4fvNV 4272
9625 void
9626 __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
9627 {
9628 __GLXcontext *const gc = __glXGetCurrentContext();
9629 const GLuint cmdlen = 24;
9630 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
9631 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9632 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
9633 gc->pc += cmdlen;
9634 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9635 (void) __glXFlushRenderBuffer(gc, gc->pc);
9636 }
9637 }
9638
9639 #define X_GLrop_VertexAttrib4svNV 4268
9640 void
9641 __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z,
9642 GLshort w)
9643 {
9644 __GLXcontext *const gc = __glXGetCurrentContext();
9645 const GLuint cmdlen = 16;
9646 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
9647 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9648 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9649 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9650 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
9651 (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
9652 gc->pc += cmdlen;
9653 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9654 (void) __glXFlushRenderBuffer(gc, gc->pc);
9655 }
9656 }
9657
9658 #define X_GLrop_VertexAttrib4svNV 4268
9659 void
9660 __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
9661 {
9662 __GLXcontext *const gc = __glXGetCurrentContext();
9663 const GLuint cmdlen = 16;
9664 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
9665 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9666 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9667 gc->pc += cmdlen;
9668 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9669 (void) __glXFlushRenderBuffer(gc, gc->pc);
9670 }
9671 }
9672
9673 #define X_GLrop_VertexAttrib4ubvNV 4277
9674 void
9675 __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z,
9676 GLubyte w)
9677 {
9678 __GLXcontext *const gc = __glXGetCurrentContext();
9679 const GLuint cmdlen = 12;
9680 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
9681 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9682 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
9683 (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
9684 (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
9685 (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
9686 gc->pc += cmdlen;
9687 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9688 (void) __glXFlushRenderBuffer(gc, gc->pc);
9689 }
9690 }
9691
9692 #define X_GLrop_VertexAttrib4ubvNV 4277
9693 void
9694 __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v)
9695 {
9696 __GLXcontext *const gc = __glXGetCurrentContext();
9697 const GLuint cmdlen = 12;
9698 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
9699 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9700 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9701 gc->pc += cmdlen;
9702 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9703 (void) __glXFlushRenderBuffer(gc, gc->pc);
9704 }
9705 }
9706
9707 #define X_GLrop_VertexAttribs1dvNV 4210
9708 void
9709 __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
9710 {
9711 __GLXcontext *const gc = __glXGetCurrentContext();
9712 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9713 if (n < 0) {
9714 __glXSetError(gc, GL_INVALID_VALUE);
9715 return;
9716 }
9717 if (__builtin_expect(n >= 0, 1)) {
9718 emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
9719 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9720 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9721 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9722 gc->pc += cmdlen;
9723 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9724 (void) __glXFlushRenderBuffer(gc, gc->pc);
9725 }
9726 }
9727 }
9728
9729 #define X_GLrop_VertexAttribs1fvNV 4206
9730 void
9731 __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
9732 {
9733 __GLXcontext *const gc = __glXGetCurrentContext();
9734 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9735 if (n < 0) {
9736 __glXSetError(gc, GL_INVALID_VALUE);
9737 return;
9738 }
9739 if (__builtin_expect(n >= 0, 1)) {
9740 emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
9741 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9742 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9743 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9744 gc->pc += cmdlen;
9745 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9746 (void) __glXFlushRenderBuffer(gc, gc->pc);
9747 }
9748 }
9749 }
9750
9751 #define X_GLrop_VertexAttribs1svNV 4202
9752 void
9753 __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
9754 {
9755 __GLXcontext *const gc = __glXGetCurrentContext();
9756 const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
9757 if (n < 0) {
9758 __glXSetError(gc, GL_INVALID_VALUE);
9759 return;
9760 }
9761 if (__builtin_expect(n >= 0, 1)) {
9762 emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
9763 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9764 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9765 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 2));
9766 gc->pc += cmdlen;
9767 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9768 (void) __glXFlushRenderBuffer(gc, gc->pc);
9769 }
9770 }
9771 }
9772
9773 #define X_GLrop_VertexAttribs2dvNV 4211
9774 void
9775 __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
9776 {
9777 __GLXcontext *const gc = __glXGetCurrentContext();
9778 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
9779 if (n < 0) {
9780 __glXSetError(gc, GL_INVALID_VALUE);
9781 return;
9782 }
9783 if (__builtin_expect(n >= 0, 1)) {
9784 emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
9785 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9786 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9787 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
9788 gc->pc += cmdlen;
9789 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9790 (void) __glXFlushRenderBuffer(gc, gc->pc);
9791 }
9792 }
9793 }
9794
9795 #define X_GLrop_VertexAttribs2fvNV 4207
9796 void
9797 __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
9798 {
9799 __GLXcontext *const gc = __glXGetCurrentContext();
9800 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9801 if (n < 0) {
9802 __glXSetError(gc, GL_INVALID_VALUE);
9803 return;
9804 }
9805 if (__builtin_expect(n >= 0, 1)) {
9806 emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
9807 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9808 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9809 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9810 gc->pc += cmdlen;
9811 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9812 (void) __glXFlushRenderBuffer(gc, gc->pc);
9813 }
9814 }
9815 }
9816
9817 #define X_GLrop_VertexAttribs2svNV 4203
9818 void
9819 __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
9820 {
9821 __GLXcontext *const gc = __glXGetCurrentContext();
9822 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9823 if (n < 0) {
9824 __glXSetError(gc, GL_INVALID_VALUE);
9825 return;
9826 }
9827 if (__builtin_expect(n >= 0, 1)) {
9828 emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
9829 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9830 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9831 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9832 gc->pc += cmdlen;
9833 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9834 (void) __glXFlushRenderBuffer(gc, gc->pc);
9835 }
9836 }
9837 }
9838
9839 #define X_GLrop_VertexAttribs3dvNV 4212
9840 void
9841 __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
9842 {
9843 __GLXcontext *const gc = __glXGetCurrentContext();
9844 const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
9845 if (n < 0) {
9846 __glXSetError(gc, GL_INVALID_VALUE);
9847 return;
9848 }
9849 if (__builtin_expect(n >= 0, 1)) {
9850 emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
9851 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9852 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9853 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 24));
9854 gc->pc += cmdlen;
9855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9856 (void) __glXFlushRenderBuffer(gc, gc->pc);
9857 }
9858 }
9859 }
9860
9861 #define X_GLrop_VertexAttribs3fvNV 4208
9862 void
9863 __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
9864 {
9865 __GLXcontext *const gc = __glXGetCurrentContext();
9866 const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
9867 if (n < 0) {
9868 __glXSetError(gc, GL_INVALID_VALUE);
9869 return;
9870 }
9871 if (__builtin_expect(n >= 0, 1)) {
9872 emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
9873 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9874 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9875 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 12));
9876 gc->pc += cmdlen;
9877 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9878 (void) __glXFlushRenderBuffer(gc, gc->pc);
9879 }
9880 }
9881 }
9882
9883 #define X_GLrop_VertexAttribs3svNV 4204
9884 void
9885 __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
9886 {
9887 __GLXcontext *const gc = __glXGetCurrentContext();
9888 const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
9889 if (n < 0) {
9890 __glXSetError(gc, GL_INVALID_VALUE);
9891 return;
9892 }
9893 if (__builtin_expect(n >= 0, 1)) {
9894 emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
9895 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9896 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9897 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 6));
9898 gc->pc += cmdlen;
9899 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9900 (void) __glXFlushRenderBuffer(gc, gc->pc);
9901 }
9902 }
9903 }
9904
9905 #define X_GLrop_VertexAttribs4dvNV 4213
9906 void
9907 __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
9908 {
9909 __GLXcontext *const gc = __glXGetCurrentContext();
9910 const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
9911 if (n < 0) {
9912 __glXSetError(gc, GL_INVALID_VALUE);
9913 return;
9914 }
9915 if (__builtin_expect(n >= 0, 1)) {
9916 emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
9917 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9918 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9919 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 32));
9920 gc->pc += cmdlen;
9921 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9922 (void) __glXFlushRenderBuffer(gc, gc->pc);
9923 }
9924 }
9925 }
9926
9927 #define X_GLrop_VertexAttribs4fvNV 4209
9928 void
9929 __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
9930 {
9931 __GLXcontext *const gc = __glXGetCurrentContext();
9932 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
9933 if (n < 0) {
9934 __glXSetError(gc, GL_INVALID_VALUE);
9935 return;
9936 }
9937 if (__builtin_expect(n >= 0, 1)) {
9938 emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
9939 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9940 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9941 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
9942 gc->pc += cmdlen;
9943 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9944 (void) __glXFlushRenderBuffer(gc, gc->pc);
9945 }
9946 }
9947 }
9948
9949 #define X_GLrop_VertexAttribs4svNV 4205
9950 void
9951 __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
9952 {
9953 __GLXcontext *const gc = __glXGetCurrentContext();
9954 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9955 if (n < 0) {
9956 __glXSetError(gc, GL_INVALID_VALUE);
9957 return;
9958 }
9959 if (__builtin_expect(n >= 0, 1)) {
9960 emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
9961 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9962 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9963 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9964 gc->pc += cmdlen;
9965 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9966 (void) __glXFlushRenderBuffer(gc, gc->pc);
9967 }
9968 }
9969 }
9970
9971 #define X_GLrop_VertexAttribs4ubvNV 4214
9972 void
9973 __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte *v)
9974 {
9975 __GLXcontext *const gc = __glXGetCurrentContext();
9976 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9977 if (n < 0) {
9978 __glXSetError(gc, GL_INVALID_VALUE);
9979 return;
9980 }
9981 if (__builtin_expect(n >= 0, 1)) {
9982 emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
9983 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9984 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9985 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9986 gc->pc += cmdlen;
9987 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9988 (void) __glXFlushRenderBuffer(gc, gc->pc);
9989 }
9990 }
9991 }
9992
9993 #define X_GLrop_PointParameteriNV 4221
9994 void
9995 __indirect_glPointParameteriNV(GLenum pname, GLint param)
9996 {
9997 __GLXcontext *const gc = __glXGetCurrentContext();
9998 const GLuint cmdlen = 12;
9999 emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
10000 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
10001 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
10002 gc->pc += cmdlen;
10003 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10004 (void) __glXFlushRenderBuffer(gc, gc->pc);
10005 }
10006 }
10007
10008 #define X_GLrop_PointParameterivNV 4222
10009 void
10010 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
10011 {
10012 __GLXcontext *const gc = __glXGetCurrentContext();
10013 const GLuint compsize = __glPointParameterivNV_size(pname);
10014 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
10015 emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
10016 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
10017 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
10018 gc->pc += cmdlen;
10019 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10020 (void) __glXFlushRenderBuffer(gc, gc->pc);
10021 }
10022 }
10023
10024 #define X_GLrop_ActiveStencilFaceEXT 4220
10025 void
10026 __indirect_glActiveStencilFaceEXT(GLenum face)
10027 {
10028 __GLXcontext *const gc = __glXGetCurrentContext();
10029 const GLuint cmdlen = 8;
10030 emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
10031 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
10032 gc->pc += cmdlen;
10033 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10034 (void) __glXFlushRenderBuffer(gc, gc->pc);
10035 }
10036 }
10037
10038 #define X_GLvop_GetProgramNamedParameterdvNV 1311
10039 void
10040 __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len,
10041 const GLubyte *name,
10042 GLdouble * params)
10043 {
10044 __GLXcontext *const gc = __glXGetCurrentContext();
10045 Display *const dpy = gc->currentDpy;
10046 const GLuint cmdlen = 8 + __GLX_PAD(len);
10047 if (len < 0) {
10048 __glXSetError(gc, GL_INVALID_VALUE);
10049 return;
10050 }
10051 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
10052 GLubyte const *pc =
10053 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10054 X_GLvop_GetProgramNamedParameterdvNV,
10055 cmdlen);
10056 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
10057 (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
10058 (void) memcpy((void *) (pc + 8), (void *) (name), len);
10059 (void) __glXReadReply(dpy, 8, params, GL_TRUE);
10060 UnlockDisplay(dpy);
10061 SyncHandle();
10062 }
10063 return;
10064 }
10065
10066 #define X_GLvop_GetProgramNamedParameterfvNV 1310
10067 void
10068 __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len,
10069 const GLubyte *name,
10070 GLfloat * params)
10071 {
10072 __GLXcontext *const gc = __glXGetCurrentContext();
10073 Display *const dpy = gc->currentDpy;
10074 const GLuint cmdlen = 8 + __GLX_PAD(len);
10075 if (len < 0) {
10076 __glXSetError(gc, GL_INVALID_VALUE);
10077 return;
10078 }
10079 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
10080 GLubyte const *pc =
10081 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10082 X_GLvop_GetProgramNamedParameterfvNV,
10083 cmdlen);
10084 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
10085 (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
10086 (void) memcpy((void *) (pc + 8), (void *) (name), len);
10087 (void) __glXReadReply(dpy, 4, params, GL_TRUE);
10088 UnlockDisplay(dpy);
10089 SyncHandle();
10090 }
10091 return;
10092 }
10093
10094 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10095 void
10096 __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len,
10097 const GLubyte *name, GLdouble x,
10098 GLdouble y, GLdouble z, GLdouble w)
10099 {
10100 __GLXcontext *const gc = __glXGetCurrentContext();
10101 const GLuint cmdlen = 44 + __GLX_PAD(len);
10102 if (len < 0) {
10103 __glXSetError(gc, GL_INVALID_VALUE);
10104 return;
10105 }
10106 if (__builtin_expect(len >= 0, 1)) {
10107 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
10108 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
10109 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
10110 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
10111 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
10112 (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
10113 (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
10114 (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
10115 gc->pc += cmdlen;
10116 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10117 (void) __glXFlushRenderBuffer(gc, gc->pc);
10118 }
10119 }
10120 }
10121
10122 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10123 void
10124 __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len,
10125 const GLubyte *name,
10126 const GLdouble * v)
10127 {
10128 __GLXcontext *const gc = __glXGetCurrentContext();
10129 const GLuint cmdlen = 44 + __GLX_PAD(len);
10130 if (len < 0) {
10131 __glXSetError(gc, GL_INVALID_VALUE);
10132 return;
10133 }
10134 if (__builtin_expect(len >= 0, 1)) {
10135 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
10136 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
10137 (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
10138 (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
10139 (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
10140 gc->pc += cmdlen;
10141 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10142 (void) __glXFlushRenderBuffer(gc, gc->pc);
10143 }
10144 }
10145 }
10146
10147 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10148 void
10149 __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len,
10150 const GLubyte *name, GLfloat x,
10151 GLfloat y, GLfloat z, GLfloat w)
10152 {
10153 __GLXcontext *const gc = __glXGetCurrentContext();
10154 const GLuint cmdlen = 28 + __GLX_PAD(len);
10155 if (len < 0) {
10156 __glXSetError(gc, GL_INVALID_VALUE);
10157 return;
10158 }
10159 if (__builtin_expect(len >= 0, 1)) {
10160 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
10161 (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
10162 (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
10163 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
10164 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
10165 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
10166 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
10167 (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
10168 gc->pc += cmdlen;
10169 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10170 (void) __glXFlushRenderBuffer(gc, gc->pc);
10171 }
10172 }
10173 }
10174
10175 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10176 void
10177 __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len,
10178 const GLubyte *name,
10179 const GLfloat * v)
10180 {
10181 __GLXcontext *const gc = __glXGetCurrentContext();
10182 const GLuint cmdlen = 28 + __GLX_PAD(len);
10183 if (len < 0) {
10184 __glXSetError(gc, GL_INVALID_VALUE);
10185 return;
10186 }
10187 if (__builtin_expect(len >= 0, 1)) {
10188 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
10189 (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
10190 (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
10191 (void) memcpy((void *) (gc->pc + 12), (void *) (v), 16);
10192 (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
10193 gc->pc += cmdlen;
10194 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10195 (void) __glXFlushRenderBuffer(gc, gc->pc);
10196 }
10197 }
10198 }
10199
10200 #define X_GLrop_BlendEquationSeparateEXT 4228
10201 void
10202 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
10203 {
10204 __GLXcontext *const gc = __glXGetCurrentContext();
10205 const GLuint cmdlen = 12;
10206 emit_header(gc->pc, X_GLrop_BlendEquationSeparateEXT, cmdlen);
10207 (void) memcpy((void *) (gc->pc + 4), (void *) (&modeRGB), 4);
10208 (void) memcpy((void *) (gc->pc + 8), (void *) (&modeA), 4);
10209 gc->pc += cmdlen;
10210 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10211 (void) __glXFlushRenderBuffer(gc, gc->pc);
10212 }
10213 }
10214
10215 #define X_GLrop_BindFramebufferEXT 4319
10216 void
10217 __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
10218 {
10219 __GLXcontext *const gc = __glXGetCurrentContext();
10220 const GLuint cmdlen = 12;
10221 emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
10222 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10223 (void) memcpy((void *) (gc->pc + 8), (void *) (&framebuffer), 4);
10224 gc->pc += cmdlen;
10225 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10226 (void) __glXFlushRenderBuffer(gc, gc->pc);
10227 }
10228 }
10229
10230 #define X_GLrop_BindRenderbufferEXT 4316
10231 void
10232 __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
10233 {
10234 __GLXcontext *const gc = __glXGetCurrentContext();
10235 const GLuint cmdlen = 12;
10236 emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
10237 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10238 (void) memcpy((void *) (gc->pc + 8), (void *) (&renderbuffer), 4);
10239 gc->pc += cmdlen;
10240 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10241 (void) __glXFlushRenderBuffer(gc, gc->pc);
10242 }
10243 }
10244
10245 #define X_GLvop_CheckFramebufferStatusEXT 1427
10246 GLenum
10247 __indirect_glCheckFramebufferStatusEXT(GLenum target)
10248 {
10249 __GLXcontext *const gc = __glXGetCurrentContext();
10250 Display *const dpy = gc->currentDpy;
10251 GLenum retval = (GLenum) 0;
10252 const GLuint cmdlen = 4;
10253 if (__builtin_expect(dpy != NULL, 1)) {
10254 GLubyte const *pc =
10255 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10256 X_GLvop_CheckFramebufferStatusEXT,
10257 cmdlen);
10258 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10259 retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10260 UnlockDisplay(dpy);
10261 SyncHandle();
10262 }
10263 return retval;
10264 }
10265
10266 #define X_GLrop_DeleteFramebuffersEXT 4320
10267 void
10268 __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
10269 {
10270 __GLXcontext *const gc = __glXGetCurrentContext();
10271 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
10272 if (n < 0) {
10273 __glXSetError(gc, GL_INVALID_VALUE);
10274 return;
10275 }
10276 if (__builtin_expect(n >= 0, 1)) {
10277 emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
10278 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
10279 (void) memcpy((void *) (gc->pc + 8), (void *) (framebuffers),
10280 (n * 4));
10281 gc->pc += cmdlen;
10282 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10283 (void) __glXFlushRenderBuffer(gc, gc->pc);
10284 }
10285 }
10286 }
10287
10288 #define X_GLrop_DeleteRenderbuffersEXT 4317
10289 void
10290 __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
10291 {
10292 __GLXcontext *const gc = __glXGetCurrentContext();
10293 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
10294 if (n < 0) {
10295 __glXSetError(gc, GL_INVALID_VALUE);
10296 return;
10297 }
10298 if (__builtin_expect(n >= 0, 1)) {
10299 emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
10300 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
10301 (void) memcpy((void *) (gc->pc + 8), (void *) (renderbuffers),
10302 (n * 4));
10303 gc->pc += cmdlen;
10304 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10305 (void) __glXFlushRenderBuffer(gc, gc->pc);
10306 }
10307 }
10308 }
10309
10310 #define X_GLrop_FramebufferRenderbufferEXT 4324
10311 void
10312 __indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment,
10313 GLenum renderbuffertarget,
10314 GLuint renderbuffer)
10315 {
10316 __GLXcontext *const gc = __glXGetCurrentContext();
10317 const GLuint cmdlen = 20;
10318 emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
10319 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10320 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10321 (void) memcpy((void *) (gc->pc + 12), (void *) (&renderbuffertarget), 4);
10322 (void) memcpy((void *) (gc->pc + 16), (void *) (&renderbuffer), 4);
10323 gc->pc += cmdlen;
10324 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10325 (void) __glXFlushRenderBuffer(gc, gc->pc);
10326 }
10327 }
10328
10329 #define X_GLrop_FramebufferTexture1DEXT 4321
10330 void
10331 __indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment,
10332 GLenum textarget, GLuint texture,
10333 GLint level)
10334 {
10335 __GLXcontext *const gc = __glXGetCurrentContext();
10336 const GLuint cmdlen = 24;
10337 emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
10338 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10339 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10340 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10341 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10342 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10343 gc->pc += cmdlen;
10344 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10345 (void) __glXFlushRenderBuffer(gc, gc->pc);
10346 }
10347 }
10348
10349 #define X_GLrop_FramebufferTexture2DEXT 4322
10350 void
10351 __indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment,
10352 GLenum textarget, GLuint texture,
10353 GLint level)
10354 {
10355 __GLXcontext *const gc = __glXGetCurrentContext();
10356 const GLuint cmdlen = 24;
10357 emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
10358 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10359 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10360 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10361 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10362 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10363 gc->pc += cmdlen;
10364 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10365 (void) __glXFlushRenderBuffer(gc, gc->pc);
10366 }
10367 }
10368
10369 #define X_GLrop_FramebufferTexture3DEXT 4323
10370 void
10371 __indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment,
10372 GLenum textarget, GLuint texture,
10373 GLint level, GLint zoffset)
10374 {
10375 __GLXcontext *const gc = __glXGetCurrentContext();
10376 const GLuint cmdlen = 28;
10377 emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
10378 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10379 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10380 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10381 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10382 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10383 (void) memcpy((void *) (gc->pc + 24), (void *) (&zoffset), 4);
10384 gc->pc += cmdlen;
10385 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10386 (void) __glXFlushRenderBuffer(gc, gc->pc);
10387 }
10388 }
10389
10390 #define X_GLvop_GenFramebuffersEXT 1426
10391 void
10392 __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
10393 {
10394 __GLXcontext *const gc = __glXGetCurrentContext();
10395 Display *const dpy = gc->currentDpy;
10396 const GLuint cmdlen = 4;
10397 if (n < 0) {
10398 __glXSetError(gc, GL_INVALID_VALUE);
10399 return;
10400 }
10401 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
10402 GLubyte const *pc =
10403 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10404 X_GLvop_GenFramebuffersEXT, cmdlen);
10405 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
10406 (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
10407 UnlockDisplay(dpy);
10408 SyncHandle();
10409 }
10410 return;
10411 }
10412
10413 #define X_GLvop_GenRenderbuffersEXT 1423
10414 void
10415 __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
10416 {
10417 __GLXcontext *const gc = __glXGetCurrentContext();
10418 Display *const dpy = gc->currentDpy;
10419 const GLuint cmdlen = 4;
10420 if (n < 0) {
10421 __glXSetError(gc, GL_INVALID_VALUE);
10422 return;
10423 }
10424 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
10425 GLubyte const *pc =
10426 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10427 X_GLvop_GenRenderbuffersEXT, cmdlen);
10428 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
10429 (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
10430 UnlockDisplay(dpy);
10431 SyncHandle();
10432 }
10433 return;
10434 }
10435
10436 #define X_GLrop_GenerateMipmapEXT 4325
10437 void
10438 __indirect_glGenerateMipmapEXT(GLenum target)
10439 {
10440 __GLXcontext *const gc = __glXGetCurrentContext();
10441 const GLuint cmdlen = 8;
10442 emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
10443 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10444 gc->pc += cmdlen;
10445 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10446 (void) __glXFlushRenderBuffer(gc, gc->pc);
10447 }
10448 }
10449
10450 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10451 void
10452 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target,
10453 GLenum attachment,
10454 GLenum pname,
10455 GLint * params)
10456 {
10457 __GLXcontext *const gc = __glXGetCurrentContext();
10458 Display *const dpy = gc->currentDpy;
10459 const GLuint cmdlen = 12;
10460 if (__builtin_expect(dpy != NULL, 1)) {
10461 GLubyte const *pc =
10462 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10463 X_GLvop_GetFramebufferAttachmentParameterivEXT,
10464 cmdlen);
10465 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10466 (void) memcpy((void *) (pc + 4), (void *) (&attachment), 4);
10467 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
10468 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
10469 UnlockDisplay(dpy);
10470 SyncHandle();
10471 }
10472 return;
10473 }
10474
10475 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10476 void
10477 __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname,
10478 GLint * params)
10479 {
10480 __GLXcontext *const gc = __glXGetCurrentContext();
10481 Display *const dpy = gc->currentDpy;
10482 const GLuint cmdlen = 8;
10483 if (__builtin_expect(dpy != NULL, 1)) {
10484 GLubyte const *pc =
10485 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10486 X_GLvop_GetRenderbufferParameterivEXT,
10487 cmdlen);
10488 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10489 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
10490 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
10491 UnlockDisplay(dpy);
10492 SyncHandle();
10493 }
10494 return;
10495 }
10496
10497 #define X_GLvop_IsFramebufferEXT 1425
10498 GLboolean
10499 __indirect_glIsFramebufferEXT(GLuint framebuffer)
10500 {
10501 __GLXcontext *const gc = __glXGetCurrentContext();
10502 Display *const dpy = gc->currentDpy;
10503 GLboolean retval = (GLboolean) 0;
10504 const GLuint cmdlen = 4;
10505 if (__builtin_expect(dpy != NULL, 1)) {
10506 GLubyte const *pc =
10507 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10508 X_GLvop_IsFramebufferEXT, cmdlen);
10509 (void) memcpy((void *) (pc + 0), (void *) (&framebuffer), 4);
10510 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10511 UnlockDisplay(dpy);
10512 SyncHandle();
10513 }
10514 return retval;
10515 }
10516
10517 #define X_GLvop_IsRenderbufferEXT 1422
10518 GLboolean
10519 __indirect_glIsRenderbufferEXT(GLuint renderbuffer)
10520 {
10521 __GLXcontext *const gc = __glXGetCurrentContext();
10522 Display *const dpy = gc->currentDpy;
10523 GLboolean retval = (GLboolean) 0;
10524 const GLuint cmdlen = 4;
10525 if (__builtin_expect(dpy != NULL, 1)) {
10526 GLubyte const *pc =
10527 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10528 X_GLvop_IsRenderbufferEXT, cmdlen);
10529 (void) memcpy((void *) (pc + 0), (void *) (&renderbuffer), 4);
10530 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10531 UnlockDisplay(dpy);
10532 SyncHandle();
10533 }
10534 return retval;
10535 }
10536
10537 #define X_GLrop_RenderbufferStorageEXT 4318
10538 void
10539 __indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat,
10540 GLsizei width, GLsizei height)
10541 {
10542 __GLXcontext *const gc = __glXGetCurrentContext();
10543 const GLuint cmdlen = 20;
10544 emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
10545 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10546 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
10547 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
10548 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
10549 gc->pc += cmdlen;
10550 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10551 (void) __glXFlushRenderBuffer(gc, gc->pc);
10552 }
10553 }
10554
10555
10556 # undef FASTCALL
10557 # undef NOINLINE